diff --git a/doc/paper.md b/doc/paper.md new file mode 100644 index 00000000..e2ae58f0 --- /dev/null +++ b/doc/paper.md @@ -0,0 +1,127 @@ +--- +title: "Informe sobre el trabajo de Compilación de cuarto año de Ciencias de la Computación" +author: [Alejandro Díaz Roque] +date: "2021-01-25" +subject: "Compilación" +keywords: [análisis sintáctico, análisis semántico, generación de código] +subtitle: "Implementación en python3 de un compilador del lenguaje de programación COOL" +lang: "es-419" + +toc: yes +numbersections: yes +titlepage: true +--- + +# Introducción + +El presente informe trata sobre la implementación en `python` de un compilador +del lenguaje `COOL` (Class Room Object Oriented Language), un software que se encarga de tomar ficheros escritos en `COOL`, y trasladarlos a código máquina ejecutable por un sistema operativo. El código máquina en este caso es `MIPS32`. +Se especificarán las componentes en que se encuentra dividido dicho software, los detalles relevantes en la implementación de cada una, y además se dará una breve explicación de cómo instalar y ejecutar el programa. + +# División en Componentes + +El compilador se encuentra dividido en 4 componentes principales: + +- **Lexer**: Que se encarga del análisis lexicográfico. Aquí se definen los tokens del lenguaje COOL. +- **Parser**: Donde se define la gramática especificada en el estándar de COOL, y donde además se construye el árbol de derivación correspondiente a la cadena asociada a un fichero para dicha gramática. +- **Semantic**: Donde se definen las clases que están dentro del fichero `.cl`, se crea la jerarquía entre ellas, y además se hace chequeo de tipos para las operaciones que se ejecuten dentro del `.cl`. +- **Generation**: Donde se traslada un `.cl` a un fichero `.mips` equivalente. Para ello, se define una representación intermedia, denominada `CIL` (Class Intermediate Language), se traduce el contenido del archivo `.cl` a esa representación, y lo resultante se traslada a un archivo `.mips`, ejecutable por una arquitectura `MIPS32`. + +## Análisis lexicográfico + +Dentro de la carpeta `/src/compiler/components/lexer`, se encuentra el fichero `lexer_analyzer.py`. En este se define todo lo necesario para construir la lista de tokens de `COOL`. Se usa el módulo `ply.lex` de `python` como framework, para hacer esta tarea de modo ágil. + +Luego de ser construidp el lexer, al archivo de entrada se le aplica la operación de *tokenización*, que consiste en dividir el texto escrito en `COOL` en diferentes tokens, según la definición del lexer. + +```python + # Este es el código para tokenizar un .cl + def tokenizer(stream_input): + global readjust_col + readjust_col = 0 + lexer.input(stream_input) + token_list = [] + lexer.lineno= 1 + #lexer.lexpos= 1 + real_col = {} + for tok in lexer: + real_col.update({ str(tok): find_column(stream_input, tok) }) + token_list.append(tok) + + + return errors, token_list, real_col + +``` + +Un detalle a resaltar es cómo se guarda la columna real de cada token. Por un lado se usa el diccionario `real_col`, que tiene como llave la representación en `string` de cada token y como valor el método `find_column`, que retorna la posición del token en la entrada. Y por el otro, se usa el sistema de seguimiento `ply.lex`, que pone en el atributo `lexpos` de cada token su número de ocurrencia, y la variable global `readjust_col`, para reajustar el valor de `lexpos` cuando hay un salto de línea. Esto es para reportar un error con la posición conveniente. + +## Análisis sintáctico + +Tomando como punto de partida lo hecho previamente en el análisis lexicográfico, usando el módulo `ply.yacc`, se define la gramática de `COOL` y generar, y a partir de ella el árbol de derivación correspondiente para el archivo `.cl` de entrada. +De igual manera, en este paso se obtiene el *Abstract Syntax Tree* o `AST`, que es el que sirve de entrada a las componentes **Semantic** y **Generation**. +Para la definición del `AST`, usamos las clases que están definidas en el módulo `/src/components/semantic/AST_definitions.py`. + +## Análisis semántico + +En esta fase, nos encargamos de tres aspectos esenciales, dado un `AST` de `COOL`: + +- Chequear que todos los tipos que se usan en el `AST` existen. +- Chequear que las definiciones de dichos tipos, y de sus *features* tienen sentido bajo los estándares de `COOL`. +- Chequear que la relación de jerarquía es correcta. +- Chequear que las operaciones definidas correctamente, tengan un uso consistente. + +Para ello, se recorre el `AST` usando el patrón *visitor*, que consiste en realizar sucesivas visitas al `AST` recopilando información en cada una que se usa en la próxima. + +```python + class NodeVisitor: + def __init__(self, programContext): + self.programContext= programContext + + def visit(self, node: Node, **args): + if isinstance(self, TypeCheckerVisitor): + if issubclass(type(node), NodeBinaryOperation): + return self.visit_NodeBinaryOperation(node, **args) + + visitor_method_name = 'visit_' + node.clsname + visitor = getattr(self, visitor_method_name, self.not_implemented) + return visitor(node, **args) # Return the new context result from the visit + + def not_implemented(self, node: Node, **args): + raise Exception('Not implemented visit_{} method'.format(node.clsname)) +``` + +Cada recorrido del `AST`, es una clase que hereda de `NodeVisitor`. +Para esta componente, se usan 4 clases, o sea, 4 recorridos, en el siguiente orden: + +1. **TypeCollectorVisitor** +2. **TypeBuilderVisitor** +3. **TypeInheritanceVisitor** +4. **TypeCheckerVisitor** + +### Estructuras adicionales para los recorridos + +#### ProgramContext + +En cada recorrido, se va actualizando un objeto de tipo `globalContext` y de nombre `programContext`, que se encarga de ir actualizando toda la información necesaria para que el contexto del `AST`, tenga sentido. De esta forma, cada vez que `programContext` cambia, lo hace a través de alguno de los métodos definido en su clase asociada, y en cada método chequea, antes de la actualización, si la operación es válida. O sea, que no haya tipos redefinidos, que una operación aritmética tenga sentido, etc. + +#### Clase error + +La clase `error` se usa para definir los errores que se pueden cometer en el proceso de compilación de una entrada en `COOL`, debido a errores de escritura. Se encuentra en el archivo `/src/compiler/utils/errors.py`. Para el caso del `programContext` antes mencionado, se usa un diccionario con los posibles errores en el análisis semántico, llamado `error_selector`. + +#### Environment + +La variable `environment` es un diccionario que sirve para guardar cada nombre de objeto en el `AST` con su tipo correspondiente, para el scope de una expresión. + +## Generation Code + +Luego de que se chequea que el `AST` es consistente, se vuelve a recorrer el mismo para obtener la representación equivalente en `MIPS32`. Para esto se crean dos clases, usando la misma lógica que en la componente **Semantic**: + +1. **CILVisitor**: Para crear la representación en `CIL` del `AST`. Esta representación es un árbol. Los nodos del árbol están definidos en el archivo `/src/compiler/components/generation/CIL_definitions.py` +2. **MipsVisitor**: Para a partir del árbol `CIL`, obtener el archivo `.mips` correspondiente. Para traducir de uno a otro, se usan convenciones, teniendo en cuenta la función de cada registro y cómo se comportan las llamadas al sistema que hace `MIPS32`. + +## Cómo correr el código + +Para ejecutar el código, debe tener la versión `3.8` de `python` o superior, instalar los requerimientos que aparecen en el archivo `requirement.txt`, correr el archivo `coolc.sh` con la dirección del archivo `.cl` a compilar. + +# Conclusión + +La implementación posee detalles corregibles. No obstante, su correctitud y robustez se corresponden con lo exigido en los test de prueba que se evalúan en el *pull request*. diff --git a/doc/paper.pdf b/doc/paper.pdf new file mode 100644 index 00000000..8a6c1c1d Binary files /dev/null and b/doc/paper.pdf differ diff --git a/requirements.txt b/requirements.txt index 9eb0cad1..8cf0ffb8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,3 @@ +ply pytest pytest-ordering diff --git a/src/compiler/__init__.py b/src/compiler/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/__init__.py b/src/compiler/components/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/generation/CIL_definitions.py b/src/compiler/components/generation/CIL_definitions.py new file mode 100644 index 00000000..1f0db66c --- /dev/null +++ b/src/compiler/components/generation/CIL_definitions.py @@ -0,0 +1,403 @@ + +########################################## AST #################################################### + + +class AST: + def __init__(self): + pass + + @property + def clsname(self): + return str(self.__class__.__name__) + + def to_readable(self): + return "{}".format(self.clsname) + + def __repr__(self): + return self.__str__() + + def __str__(self): + return str(self.to_readable()) + "\n" + + +##################################### PROGRAM ##################################################### + + +class Program(AST): + def __init__(self, type_section, data_section, code_section): + super(Program, self).__init__() + self.code_section = code_section + self.data_section = data_section + self.type_section = type_section + + def to_readable(self): + ttype = "" + for t in self.type_section: + ttype += str(t) + data = "" + for t in self.data_section: + data += str(t) + code = "" + for t in self.code_section: + code += str(t) + return "CIL\n\t.TYPE\n{}\n\t.DATA\n{}\n\t.CODE\n{}\n".format(ttype, data, code) + + + +################################ TYPES, DATAS, STATEMENTS ######################################### + + +class Type(AST): + def __init__(self, name, attributes, methods): + self.type_name = name + self.attributes = attributes + self.methods = methods + + def to_readable(self): + attrs = "" + for t in self.attributes: + attrs += str(t) + "\t" + m = "" + for t in self.methods: + m += str(t) + "\t" + return "type {} {}\n\t{}\n\t{}\n{}\n".format(self.type_name, "{", attrs, m, "}") + + +class Data(AST): + def __init__(self, dest, value): + self.dest = dest + self.value = value + + def to_readable(self): + return "{} = {}\n".format(self.dest, self.value) + + +class Statement(AST): + pass + + +#################################### ATTRIBUTE ################################################### + +class TypeFeature(AST): + pass + +class Attribute(TypeFeature): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "attribute {}\n".format(self.name) + +class Method(TypeFeature): + def __init__(self, name, function_name): + self.name = name + self.function_name = function_name + + def to_readable(self): + return "method {} : {}\n".format(self.name, self.function_name) + + +#################################### FUNCTION #################################################### + + +class Function(TypeFeature): + def __init__(self, name, args, vlocals, body, returnType): + self.name = name + self.args = args + self.vlocals = vlocals + self.body = body + + #Not for print + self.returnType= returnType + + def to_readable(self): + args = "" + for t in self.args: + args += str(t) + "\t" + args += "\n" + vlocals = "" + for t in self.vlocals: + vlocals += str(t) + "\t" + args += "\n" + body = "" + for t in self.body: + body += str(t) + "\t" + body += "\n" + return "function {} {}\n\t{}\n\n\t{}\n\n\t{}\n{}\n".format(self.name, "{", args, vlocals, body, "}") + + + +class ArgDeclaration(AST): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "PARAM {}\n".format(self.name) + + +class LocalDeclaration(AST): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "LOCAL {}\n".format(self.name) + + +#################################### STATEMENTS ################################################# + + +class Assign(Statement): + def __init__(self, dest, source): + self.dest = dest + self.source = source + + def to_readable(self): + return "{} = {}\n".format(self.dest, self.source) + +#----------- BinaryOperator + +class BinaryOperator(Statement): + def __init__(self, dest, left, right, op): + self.dest = dest + self.left = left + self.right = right + self.op = op + + def to_readable(self): + return "{} = {} {} {}\n".format(self.dest, self.left, self.op, self.right) + +class Plus(BinaryOperator): + def __init__(self, dest, left, right): + super(Plus, self).__init__(dest, left, right, "+") + +class Minus(BinaryOperator): + def __init__(self, dest, left, right): + super(Minus, self).__init__(dest, left, right, "-") + +class Mult(BinaryOperator): + def __init__(self, dest, left, right): + super(Mult, self).__init__(dest, left, right, "*") + +class Div(BinaryOperator): + def __init__(self, dest, left, right): + super(Div, self).__init__(dest, left, right, "/") + +#---------- COMPARISONS + +class Equal(BinaryOperator): + def __init__(self, dest, left, right): + super(Equal, self).__init__(dest, left, right, "==") + +class LessThan(BinaryOperator): + def __init__(self, dest, left, right): + super(LessThan, self).__init__(dest, left, right, "<") + +class EqualOrLessThan(BinaryOperator): + def __init__(self, dest, left, right): + super(EqualOrLessThan, self).__init__(dest, left, right, "<=") + +#---------- TYPES + +class GetAttrib(Statement): + def __init__(self, dest, instance, attribute): + self.dest = dest + self.instance = instance + self.attribute = attribute + + def to_readable(self): + return "{} = GETATTR {} {}\n".format(self.dest, self.instance, self.attribute) + +class SetAttrib(Statement): + def __init__(self, instance, attribute, src): + self.instance = instance + self.attribute = attribute + self.src = src + + def to_readable(self): + return "SETATTR {} {} {}\n".format(self.instance, self.attribute, self.src) + +#---------- ARRAYS + +# self.attribute will represent the index + +class GetIndex(GetAttrib): + def to_readable(self): + return "{} = GETINDEX {} {}\n".format(self.dest, self.instance, self.attribute) + + +class SetIndex(SetAttrib): + def to_readable(self): + return "SETINDEX {} {} {}\n".format(self.instance, self.attribute, self.src) + + +################################ MEMORY STATEMENTS ############################################## + + +class TypeOf(Statement): + def __init__(self, dest, instance): + self.dest = dest + self.instance = instance + + def to_readable(self): + return "{} = TYPEOF {}\n".format(self.dest, self.instance) + + + +class Allocate(Statement): + def __init__(self, dest, ttype): + self.dest = dest + self.ttype = ttype + + def to_readable(self): + return "{} = ALLOCATE {}\n".format(self.dest, self.ttype) + + +class Array(Statement): + def __init__(self, dest, src): + self.dest = dest + self.src = src + + def to_readable(self): + return "{} = ARRAY {}\n".format(self.dest, self.src) + + + + +################################# DISPATCH STATEMENTS, RETURN ################################# + + +class Call(Statement): + def __init__(self, dest, f): + self.dest = dest + self.f = f + + def to_readable(self): + return "{} = CALL {}\n".format(self.dest, self.f) + + +class VCall(Statement): + def __init__(self, dest, ttype, f): + self.dest = dest + self.ttype = ttype + self.f = f + + def to_readable(self): + return "{} = VCALL {} {}\n".format(self.dest, self.ttype, self.f) + + +class PushParam(Statement): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "ARG {}\n".format(self.name) + +class PopParam(Statement): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "POP {}\n".format(self.name) + +class Return(Statement): + def __init__(self, value=None): + self.value = value + + def to_readable(self): + return "RETURN {}\n".format(self.value) + +################################## JUMP STATEMENTS ########################################### + + +class Label(Statement): + def __init__(self, name): + self.name = name + + def to_readable(self): + return "LABEL {}\n".format(self.name) + +class Goto(Statement): + def __init__(self, label): + self.label = label + + def to_readable(self): + return "GOTO {}\n".format(self.label) + +class IfGoto(Statement): + def __init__(self, condition, label): + self.condition = condition + self.label = label + + def to_readable(self): + return "IF {} GOTO {}\n".format(self.condition, self.label) + +######################################## STR STATEMENTS ###################################### + + +class Load(Statement): + def __init__(self, dest, msg): + self.dest = dest + self.msg = msg + + def to_readable(self): + return "{} = LOAD {}\n".format(self.dest, self.msg) + + + +class Length(Statement): + def __init__(self, dest, str_addr): + self.dest = dest + self.str_addr = str_addr + + def to_readable(self): + return "{} = LENGTH {}\n".format(self.dest, self.str_addr) + + +class Concat(Statement): + def __init__(self, dest, first, second): + self.dest = dest + self.first = first + self.second = second + + def to_readable(self): + return "{} = CONCAT {} {}\n".format(self.dest, self.first, self.second) + + +class Substring(Statement): + def __init__(self, dest, str_addr, pos_left=0, pos_right=-1): + self.dest = dest + self.str_addr = str_addr + self.pos_left = pos_left + self.pos_right = pos_right + + def to_readable(self): + return "{} = SUBSTRING {} {} {}\n".format(self.dest, self.str_addr, self.pos_left, self.pos_right) + + +class ToString(Statement): + def __init__(self, dest, num): + self.dest = dest + self.num = num + + def to_readable(self): + return "{} = STR {}\n".format(self.dest, self.num) + + +#################################### IO STATEMENTS ########################################### + + +class Read(Statement): + def __init__(self, dest): + self.dest = dest + + def to_readable(self): + return "{} = READ\n".format(self.dest) + + +class Print(Statement): + def __init__(self, str_addr): + self.str_addr = str_addr + + def to_readable(self): + return "PRINT {}\n".format(self.str_addr) + diff --git a/src/compiler/components/generation/CIL_generator.py b/src/compiler/components/generation/CIL_generator.py new file mode 100644 index 00000000..c525644e --- /dev/null +++ b/src/compiler/components/generation/CIL_generator.py @@ -0,0 +1,708 @@ +from compiler.utils.visitors_definitions import NodeVisitor +from ..semantic.AST_definitions import * +import compiler.components.generation.CIL_definitions as cil +from compiler.components.generation.context import NameMap +from compiler.utils.errors import error + +class CILVisitor(NodeVisitor): + def __init__(self, programContext, mapExpr): + super().__init__(programContext= programContext) + self.mapExpr= mapExpr + + # Type declarations of the program + self.dottype= [] + # String declarations of the program + self.dotdata= [] + # Function declarations of the program + self.dotcode= [] + + # Data of the class being visited + self.currentClassName= "" + + # Data of the function being visited + self.currentFunctionName= "" + self.localvars= [] + self.instructions= [] + + # Attributes index map[][] + self.attrIndexMap= {} + + # Methods index map + self.mthMap= {} + + # Counters to make variable's names unique + self.internalVarCount = 0 # LOCAL variables + self.internalLabelCount = 0 # LABELs + + + # Add static code + self.addBuiltIns() + + # Class depth dictionary used to analyze Case expressions + self.classDepth= {} + + + def addBuiltIns(self): + # Add static types, functions and string constants + self.emptyString = self.registerData("") + + self.dottype.append(cil.Type('void', [], [])) + + #---------- LABELs + def defineInternalLabel(self): + label = f'LABEL_{self.internalLabelCount}' + self.internalLabelCount += 1 + return label + + #---------- .TYPE + def registerType(self, ttype): + self.dottype.append(ttype) + + #---------- .DATA + def registerData(self, value): + vname = f'data_{len(self.dotdata)}' + sameData = [data for data in self.dotdata if data.value == value] + if sameData != []: + return sameData[0].dest + + dataNode = cil.Data(vname, value) + self.dotdata.append(dataNode) + return dataNode.dest + + #---------- .CODE + + def buildInternalVname(self, vname): + vname = f'_{vname}_{self.internalVarCount}' + return vname + + def registerInternalLocal(self): + return self.registerLocal('internal') + + def registerLocal(self, vname): + vname = self.buildInternalVname(vname) + self.localvars.append(cil.LocalDeclaration(vname)) + self.internalVarCount +=1 + return vname + + def registerInstruction(self, instructionType, *args): + instruction = instructionType(*args) + self.instructions.append(instruction) + return instruction + + def registerFunction(self, function): + self.dotcode.append(function) + + def buildNewObject(self, dest, ttype): + self.registerInstruction(cil.Allocate, dest, ttype) + self.registerInstruction(cil.PushParam, dest) + self.registerInstruction(cil.Call, dest, f'{ttype}_{"_init"}') + self.registerInstruction(cil.PopParam, dest) + + + def buildClassDepth(self, node: NodeProgram): + # Initialize class depth dictionary + for c in node.class_list: + self.classDepth[c.idName] = 0 + + for _class in node.class_list: + if _class.parent: + # Build the class depth dictionary + self.classDepth[_class.idName]= self.classDepth[_class.parent] + 1 + + + + def visit_NodeProgram(self, node: NodeProgram): + self.buildClassDepth(node) + for _class in node.class_list: + newType= self.visit(_class) + self.registerType(newType) + + for func in self.dotcode: + for inst in func.body: + if isinstance(inst, cil.VCall): + inst.f = self.mthMap[inst.f] + if (isinstance(inst, cil.SetAttrib) or isinstance(inst, cil.GetAttrib)) \ + and isinstance(inst.attribute, str): + inst.attribute = self.attrIndexMap[inst.attribute] + + return cil.Program(self.dottype, self.dotdata, self.dotcode) + + def visit_NodeClass(self, node: NodeClass): + + self.currentClassName = node.idName + # Ovewritting attrs it's not allowed, so the first attrs of the class are the inhertited + if node.idName != 'Object': + parentName= 'Object' if not node.parent else node.parent + inhAttributes = [cil.Attribute(f'{attrName}') for attrName in + self.programContext.types[node.idName].inheritsAttr] + + methods= [cil.Method(methodName, f'{self.programContext.types[parentName].inheritsMethods[methodName].wrapperType}_{methodName}') for methodName in + self.programContext.types[parentName].inheritsMethods.keys()] + methods += [cil.Method(methodName, f'{parentName}_{methodName}') for methodName in + self.programContext.types[parentName].methods.keys() if not methodName in methods] + + for i in range(len(inhAttributes)): + self.attrIndexMap[f'{self.currentClassName}_{inhAttributes[i].name}']= i + for i in range(len(methods)): + self.mthMap[f'{self.currentClassName}_{methods[i].name}']= i + else: + inhAttributes = [] + methods = [] + # Translate all the properties (COOL) into attributes (CIL) + # and build an initializer function + self.localvars= [] + self.instructions= [] + self.internalVarCount= 0 + self.currentFunctionName= f'{self.currentClassName}_{"_init"}' + + if self.currentClassName != 'Object': + # Build the initializer function and attributes list + self.registerInstruction(cil.PushParam, "__self") + self.registerInstruction(cil.Call, None, node.parent + '__init') # Call superclasses's initializers + self.registerInstruction(cil.PopParam, None) + + ind= len(inhAttributes) + naturalAttrs= [] + for nodeAttr in node.attributes: + self.currentIndex= ind + naturalAttrs.append(self.visit(nodeAttr)) + ind += 1 + + # Register the initializer function + self.registerInstruction(cil.Return, '__self') + func = cil.Function(self.currentFunctionName, + [cil.ArgDeclaration('__self')], + self.localvars, self.instructions, + node.idName) + + self.registerFunction(func) + + # Translate all Class Methods (COOL) into Type Methods (CIL) + # and the functions associated will be automatically registered by the visitor + ind = len(methods) + for nodeClassMethod in node.methods: + # Check if this method is being redefined + + index = next((i for i in range(len (methods)) + if methods[i].name == nodeClassMethod.idName), None ) + if index: + # If it's being redefined, use the offset of the function already defined + del methods[index] + ind -= 1 + + else: + index= ind + self.currentIndex= index + method = self.visit(nodeClassMethod) + methods.insert(index, method) + ind += 1 + + return cil.Type(node.idName, inhAttributes + naturalAttrs, methods) + + + def visit_NodeAttr(self, node: NodeAttr): + if node.expr: + rname = self.visit(node.expr) + self.registerInstruction(cil.SetAttrib, "__self", self.currentIndex, rname) + elif node._type == "__prim_zero_slot": + self.registerInstruction(cil.SetAttrib, "__self", self.currentIndex, 0) + elif node._type == "__prim_empty_slot": + + self.registerInstruction(cil.SetAttrib, + "__self", + self.currentIndex, + self.emptyString) + else: + _temp = self.registerInternalLocal() + if node._type == 'Int': + self.buildNewObject(_temp, 'Int') + elif node._type == 'Bool': + self.buildNewObject(_temp, 'Bool') + elif node._type == 'String': + self.buildNewObject(_temp, 'String') + else: + self.registerInstruction(cil.Allocate, _temp, 'void') + self.registerInstruction(cil.SetAttrib, "__self", self.currentIndex, _temp) + + self.attrIndexMap[f'{self.currentClassName}_{node.idName}']= self.currentIndex + return cil.Attribute(f'{self.currentClassName}_{node.idName}') + + def visit_NodeClassMethod(self, node: NodeClassMethod): + self.localvars= [] + self.instructions= [] + self.internalVarCount= 0 + self.currentFunctionName= f"{self.currentClassName}_{node.idName}" + + self.nameMap= NameMap() + + arguments= [cil.ArgDeclaration("__self")] + + for formal_param in node.formal_param_list: + arguments.append(self.visit(formal_param)) + + # If a function is built in, doesn't need CIL code. + if not self.currentClassName in self.programContext.basics: + returnVal = self.visit(node.body) + self.registerInstruction(cil.Return, returnVal) + + #----- Register the function and return the corresponding method node + func= cil.Function(self.currentFunctionName, arguments, + self.localvars, self.instructions, node.returnType) + + self.registerFunction(func) + + self.mthMap[func.name]= self.currentIndex + + return cil.Method(node.idName, func.name) + + + def visit_NodeFormalParam(self, node: NodeFormalParam): + self.nameMap.define_variable(node.idName, f'_{node.idName}') + return cil.ArgDeclaration(f'_{node.idName}') + + ################################## INSTANCES ############################## + def visit_NodeObject(self, node: NodeObject): + if node.idName == 'self': return '__self' + objVname = self.nameMap.get_cil_name(node.idName) + if objVname: + return objVname + else: + vname = self.registerLocal(node.idName) + attributeCilName = f'{self.currentClassName}_{node.idName}' + self.registerInstruction(cil.GetAttrib, + vname, + '__self', + attributeCilName) + + return vname + + def visit_NodeSelf(self, node: NodeSelf): + return '__self' + + + ################################## CONSTANTS ############################## + + def visit_NodeInteger(self, node: NodeInteger): + boxedInt = self.registerInternalLocal() + self.registerInstruction(cil.Allocate, boxedInt, 'Int') + self.registerInstruction(cil.SetAttrib, boxedInt, 0, node.content) + return boxedInt + + def visit_NodeString(self, node: NodeString): + dataVname= self.registerData(node.content) + boxedString = self.registerInternalLocal() + boxedInt = self.registerInternalLocal() + self.registerInstruction(cil.Allocate, boxedInt, 'Int') + self.registerInstruction(cil.SetAttrib, boxedInt, 0, len(node.content)) + + self.registerInstruction(cil.Allocate, boxedString, 'String') + self.registerInstruction(cil.SetAttrib, boxedString, 0, boxedInt) + self.registerInstruction(cil.SetAttrib, boxedString, 1, dataVname) + return boxedString + + def visit_NodeBoolean(self, node: NodeBoolean): + boxedBool = self.registerInternalLocal() + self.registerInstruction(cil.Allocate, boxedBool, 'Bool') + if node.content != 'false': + self.registerInstruction(cil.SetAttrib, boxedBool, 0, 1) + else: + self.registerInstruction(cil.SetAttrib, boxedBool, 0, 0) + return boxedBool + + ################################## EXPRESSIONS ############################## + + def visit_NodeNewObject(self, node: NodeNewObject): + vname = self.registerInternalLocal() + _temp = self.registerInternalLocal() + self.registerInstruction(cil.Allocate, vname, node.type) + self.registerInstruction(cil.PushParam, vname) + self.registerInstruction(cil.Call, _temp, f'{node.type}_{"_init"}') + self.registerInstruction(cil.PopParam, vname) + return vname + + def visit_NodeIsVoid(self, node: NodeIsVoid): + value = self.registerInternalLocal() + exprVal = self.visit(node.expr) + self.registerInstruction(cil.PushParam, exprVal) + self.registerInstruction(cil.Call, value, "_isvoid") + self.registerInstruction(cil.PopParam, exprVal) + return value + + def visit_NodeAssignment(self, node: NodeAssignment): + rname = self.visit(node.expr) + cilName = self.nameMap.get_cil_name(node.nodeObject.idName) + if cilName: + self.registerInstruction(cil.Assign, cilName, rname) + else: + attributeCilName = f'{self.currentClassName}_{node.nodeObject.idName}' + self.registerInstruction(cil.SetAttrib, + '__self', attributeCilName, rname) + return rname + + def visit_NodeBlock(self, node: NodeBlock): + blockValue = None + for expr in node.expr_list: + blockValue = self.visit(expr) + return blockValue + + def visit_NodeLetComplex(self, node: NodeLetComplex): + self.nameMap = self.nameMap.create_child_scope() + for nodeLet in node.nestedLets: + self.visit(nodeLet) + + res_vname = self.visit(node.body) + self.nameMap.exit_child_scope() + + return res_vname + + def visit_NodeLet(self, node: NodeLet): + varName = "" + if node.body: + varName = self.visit(node.body) + else: + varName = self.registerLocal(node.idName) + if node.type == 'Int': + self.buildNewObject(varName, 'Int') + elif node.type == 'Bool': + self.buildNewObject(varName, 'Bool') + elif node.type == 'String': + self.buildNewObject(varName, 'String') + elif node.type == '__prim_zero_slot': + self.register_instruction(cil.SetAttrib, '__self', self.currentIndex, 0) + elif node.type == '__prim_empty_slot': + self.register_instruction(cil.SetAttrib, '__self', self.currentIndex, self.emptyString) + else: + self.registerInstruction(cil.Allocate, varName, 'void') + + self.nameMap.define_variable(node.idName, varName) + + def visit_NodeIf(self, node: NodeIf): + # LOCAL + # + # + # + # ... + # + # condition-unboxed = GetAttr _value + # if condition-unboxed GOTO then_lbl + # + # = + # GOTO continue_lbl + # LABEL then_lbl: + # + # = + # LABEL continue_lbl: + + # <.locals> + ifValue = self.registerInternalLocal() + conditionUnboxed = self.registerInternalLocal() + thenLbl = self.defineInternalLabel() + continueLbl = self.defineInternalLabel() + + # <.body> + conditionValue = self.visit(node.predicate) + self.registerInstruction(cil.GetAttrib, conditionUnboxed, conditionValue, 0) + self.registerInstruction(cil.IfGoto, conditionUnboxed, thenLbl) + elseValue = self.visit(node.else_body) + self.registerInstruction(cil.Assign, ifValue, elseValue) + self.registerInstruction(cil.Goto, continueLbl) + self.registerInstruction(cil.Label, thenLbl) + thenValue = self.visit(node.then_body) + self.registerInstruction(cil.Assign, ifValue, thenValue) + self.registerInstruction(cil.Label, continueLbl) + + return ifValue + + def visit_NodeWhileLoop(self, node: NodeWhileLoop): + # LOCAL + # + # + # ... + # LABEL start_lbl + # + # condition-unboxed = GetAttr _value + # if condition-unboxed GOTO body_lbl + # GOTO continue_lbl + # LABEL body_lbl + # + # GOTO start_lbl + # LABEL continue_lbl + # = 'VOID_TYPE' + + # <.locals> + whileValue = self.registerInternalLocal() + conditionUnboxed = self.registerInternalLocal() + startLbl = self.defineInternalLabel() + bodyLbl = self.defineInternalLabel() + continueLbl = self.defineInternalLabel() + + # <.code> + self.registerInstruction(cil.Label, startLbl) + conditionValue = self.visit(node.predicate) # Generate and + self.registerInstruction(cil.GetAttrib, conditionUnboxed, conditionValue, 0) + self.registerInstruction(cil.IfGoto, conditionUnboxed, bodyLbl) + self.registerInstruction(cil.Goto, continueLbl) + self.registerInstruction(cil.Label, bodyLbl) + self.visit(node.body) + self.registerInstruction(cil.Goto, startLbl) + self.registerInstruction(cil.Label, continueLbl) + self.registerInstruction(cil.Allocate, whileValue, 'void') + + return whileValue + + def visit_NodeCase(self, node: NodeCase): + # Sort types by their depths in the class hierarchy + actions = list(node.actions) + actions.sort(key = lambda x: self.classDepth[x.type], reverse = True) + + # <.locals> + _temp = self.registerInternalLocal() + exprType = self.registerLocal("expression_type") + caseValue = self.registerInternalLocal() + + # Labels + labels = [] + for _ in node.actions: + labels.append(self.defineInternalLabel()) + endLabel = self.defineInternalLabel() + + # <.code> + exprValue = self.visit(node.expr) + self.registerInstruction(cil.TypeOf, exprType, exprValue) + + for i in range(len(actions)): + self.registerInstruction(cil.PushParam, actions[i].type) + self.registerInstruction(cil.PushParam, exprType) + # Call conforms function : (typex, typey) -> typex <= typey + self.registerInstruction(cil.Call, _temp, "__conforms") + self.registerInstruction(cil.PopParam, None) + self.registerInstruction(cil.PopParam, None) + self.registerInstruction(cil.IfGoto, _temp, labels[i]) + + for i in range(len(actions)): + self.registerInstruction(cil.Label, labels[i]) + self.nameMap.define_variable(actions[i].idName, exprValue) + self.nameMap = self.nameMap.create_child_scope() + expr_i = self.visit(actions[i]) + self.nameMap.exit_child_scope() + self.registerInstruction(cil.Assign, caseValue, expr_i) + self.registerInstruction(cil.Goto, endLabel) + + self.registerInstruction(cil.Label, endLabel) + return caseValue + + def visit_NodeCaseAction(self, node: NodeCaseAction): + return self.visit(node.expr) + + ################################# DISPATCHS ####################################### + + def visit_NodeDynamicDispatch(self, node: NodeDynamicDispatch): + if node.method == 'abort': + # This is near to trolling. I know, is pretty ugly, but it works. + self.mapExpr[node.line + 0.5, node.column + 0.5]= "IO" + self.visit_NodeDynamicDispatch( + NodeDynamicDispatch(line= node.line + 0.5, + column= node.column + 0.5, + method= 'out_string', + expr= NodeNewObject("IO", line= -1, column=-1), + arguments= [NodeString (content= f'Abort called from class {self.mapExpr[(node.line, node.column)]}\n', line = -1, column = -1)])) + instanceVname = self.visit(node.expr) + ttype = self.registerInternalLocal() + result = self.registerInternalLocal() + + # Save the params to do Pop after calling the function + pops = [] + for i in range(len(node.arguments)-1, -1, -1): + param = node.arguments[i] + paramVname = self.visit(param) + self.registerInstruction(cil.PushParam, paramVname) + pops.append(paramVname) + + # Instance + self.registerInstruction(cil.PushParam, instanceVname) + + # Compute instance's type + self.registerInstruction(cil.TypeOf, ttype, instanceVname) + methodPrefix= self.mapExpr[(node.line, node.column)] + # Call the function + methodName = f'{methodPrefix}_{node.method}' + self.registerInstruction(cil.VCall, result, ttype, methodName) + self.registerInstruction(cil.PopParam, instanceVname) + + # Pop the arguments + for i in range(len(pops)-1, -1, -1): + self.registerInstruction(cil.PopParam, pops[i]) + + return result + + def visit_NodeStaticDispatch(self, node: NodeStaticDispatch): + instanceVname = self.visit(node.expr) + result = self.registerInternalLocal() + + # Save the params to do Pop after calling the function + pops = [] + for i in range(len(node.arguments)-1, -1, -1): + param = node.arguments[i] + paramVname = self.visit(param) + self.registerInstruction(cil.PushParam, paramVname) + pops.append(paramVname) + + # Instance + self.registerInstruction(cil.PushParam, instanceVname) + + # Call the function + method_name = f'{node.dispatch_type}_{node.method}' + self.registerInstruction(cil.VCall, result, node.dispatch_type, method_name) + self.registerInstruction(cil.PopParam, instanceVname) + + + # Pop the arguments + for i in range(len(pops)-1, -1, -1): + self.registerInstruction(cil.PopParam, pops[i]) + + return result + + def visit_NodeIntegerComplement(self, node: NodeIntegerComplement): + # <.locals> + unboxedVal = self.registerInternalLocal() + _temp = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + boxedVal = self.visit(node.integer_expr) + self.registerInstruction(cil.GetAttrib, unboxedVal, boxedVal, 0) + self.registerInstruction(cil.Minus, _temp, 0, unboxedVal) + self.registerInstruction(cil.Allocate, result, "Int") + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeBooleanComplement(self, node: NodeBooleanComplement): + # <.locals> + unboxedVal = self.registerInternalLocal() + _temp = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + boxedVal = self.visit(node.boolean_expr) + self.registerInstruction(cil.GetAttrib, unboxedVal, boxedVal, 0) + self.registerInstruction(cil.Minus, _temp, 1, unboxedVal) + self.registerInstruction(cil.Allocate, result, 'Bool') + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + ################################ BINARY OPERATIONS ################################## + + def visit_NodeAddition(self, node: NodeAddition): + # <.locals> + _temp = self.registerInternalLocal() + firstVal = self.registerInternalLocal() + secondVal = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + firstBoxed = self.visit(node.first) + secondBoxed = self.visit(node.second) + self.registerInstruction(cil.GetAttrib, firstVal, firstBoxed, 0) + self.registerInstruction(cil.GetAttrib, secondVal, secondBoxed, 0) + self.registerInstruction(cil.Plus, _temp, firstVal, secondVal) + self.registerInstruction(cil.Allocate, result, 'Int') + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeSubtraction(self, node: NodeSubtraction): + # <.locals> + _temp = self.registerInternalLocal() + firstVal = self.registerInternalLocal() + secondVal = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + firstBoxed= self.visit(node.first) + secondBoxed= self.visit(node.second) + self.registerInstruction(cil.GetAttrib, firstVal, firstBoxed, 0) + self.registerInstruction(cil.GetAttrib, secondVal, secondBoxed, 0) + self.registerInstruction(cil.Minus, _temp, firstVal, secondVal) + self.registerInstruction(cil.Allocate, result, "Int") + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeMultiplication(self, node: NodeMultiplication): + # <.locals> + _temp = self.registerInternalLocal() + firstVal = self.registerInternalLocal() + secondVal = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + firstBoxed = self.visit(node.first) + secondBoxed = self.visit(node.second) + self.registerInstruction(cil.GetAttrib, firstVal, firstBoxed, 0) + self.registerInstruction(cil.GetAttrib, secondVal, secondBoxed, 0) + self.registerInstruction(cil.Mult, _temp, firstVal, secondVal) + self.registerInstruction(cil.Allocate, result, 'Int') + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeDivision(self, node: NodeDivision): + # <.locals> + _temp = self.registerInternalLocal() + firstVal = self.registerInternalLocal() + secondVal = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + firstBoxed = self.visit(node.first) + secondBoxed = self.visit(node.second) + self.registerInstruction(cil.GetAttrib, firstVal, firstBoxed, 0) + self.registerInstruction(cil.GetAttrib, secondVal, secondBoxed, 0) + self.registerInstruction(cil.Div, _temp, firstVal, secondVal) + self.registerInstruction(cil.Allocate, result, "Int") + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeEqual(self, node: NodeEqual): + # <.locals> + _temp = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + first_val = self.visit(node.first) + second_val = self.visit(node.second) + self.registerInstruction(cil.Equal, _temp, first_val, second_val) + self.registerInstruction(cil.Allocate, result, 'Bool') + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeLessThan(self, node: NodeLessThan): + # <.locals> + _temp = self.registerInternalLocal() + first_val = self.registerInternalLocal() + second_val = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + first_boxed = self.visit(node.first) + second_boxed = self.visit(node.second) + self.registerInstruction(cil.GetAttrib, first_val, first_boxed, 0) + self.registerInstruction(cil.GetAttrib, second_val, second_boxed, 0) + self.registerInstruction(cil.LessThan, _temp, first_val, second_val) + self.registerInstruction(cil.Allocate, result, "Int") + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result + + def visit_NodeLessThanOrEqual(self, node: NodeLessThanOrEqual): + # <.locals> + _temp = self.registerInternalLocal() + firstVal = self.registerInternalLocal() + secondVal = self.registerInternalLocal() + result = self.registerInternalLocal() + + # <.code> + firstBoxed = self.visit(node.first) + secondBoxed = self.visit(node.second) + self.registerInstruction(cil.GetAttrib, firstVal, firstBoxed, 0) + self.registerInstruction(cil.GetAttrib, secondVal, secondBoxed, 0) + self.registerInstruction(cil.EqualOrLessThan, _temp, firstVal, secondVal) + self.registerInstruction(cil.Allocate, result, "Int") + self.registerInstruction(cil.SetAttrib, result, 0, _temp) + return result diff --git a/src/compiler/components/generation/MIPS_defintions.py b/src/compiler/components/generation/MIPS_defintions.py new file mode 100644 index 00000000..7c719cad --- /dev/null +++ b/src/compiler/components/generation/MIPS_defintions.py @@ -0,0 +1,257 @@ +class MIPSNode: + pass + +class MIPSProgramNode(MIPSNode): + def __init__(self, dotdata, dottext): + self.dotdata = dotdata + self.dottext = dottext + +class MIPSDataNode(MIPSNode): + pass + +class MIPSProcedureNode(MIPSNode): + def __init__(self, label): + self.label = label + self.instructions = [] + +class MIPSInstructionNode(MIPSNode): + pass + +class MIPSDataTypedNode(MIPSDataNode): + def __init__(self, vname, data_type, values): + self.vname = vname + self.data_type = data_type + self.values = values + + def __str__(self): + values = "" + for value in self.values: + values += f", {value}" + return f"{self.vname} : {self.data_type}{values}" + +class MIPSConstantNode(MIPSDataNode): + def __init__(self, vname, value): + self.vname = vname + self.value = value + +class MIPSArithmeticAndLogicNode(MIPSInstructionNode) : + def __init__(self, destination, left, right): + self.destination = destination + self.left = left + self.right = right + +class MIPSAddNode(MIPSArithmeticAndLogicNode): + def __str__(self): + return f"add {self.destination}, {self.left}, {self.right}" + +class MIPSSubstractNode(MIPSArithmeticAndLogicNode): + def __str__(self): + return f"sub {self.destination}, {self.left}, {self.right}" + +class MIPSAddInmediateNode(MIPSArithmeticAndLogicNode): + def __str__(self): + return f'addi {self.destination}, {self.left}, {self.right}' + +class MIPSAddUnsigned(MIPSArithmeticAndLogicNode): + pass + +class MIPSSubstractUnsignedNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSAddInmediateUnsignedNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSMultiplyWithoutOverflow(MIPSArithmeticAndLogicNode): + pass + +class MIPSAndNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSOrNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSAndInmediateNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSOrInmediateNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSShiftLeftNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSShiftRightNode(MIPSArithmeticAndLogicNode): + pass + +class MIPSHiLoOperationNode(MIPSInstructionNode): + def __init__(self,left,right): + self.left = left + self.right = right + +class MIPSMultiplyNode(MIPSHiLoOperationNode): + def __str__(self): + return f'mult {self.left}, {self.right}' + +class MIPSDivideNode(MIPSHiLoOperationNode): + def __str__(self): + return f'div {self.left}, {self.right}' + +class MIPSDataTransferNode(MIPSInstructionNode): + pass +class MIPSDataTransferWithOffsetNode(MIPSDataTransferNode): + def __init__(self, source, offset, destination): + self.source = source + self.offset = offset + self.destination = destination + +class MIPSLoadWordNode(MIPSDataTransferWithOffsetNode): + def __str__(self): + return f'lw {self.source}, {str(self.offset)}({self.destination})' + +class MIPSLoadByteNode(MIPSDataTransferWithOffsetNode): + def __str__(self): + return f'lb {self.source}, {str(self.offset)}({self.destination})' + +class MIPSStoreWordNode(MIPSDataTransferWithOffsetNode): + def __str__(self): + return f'sw {self.source}, {str(self.offset)}({self.destination})' + +class MIPSStoreByteNode(MIPSDataTransferWithOffsetNode): + def __str__(self): + return f'sb {self.source}, {str(self.offset)}({self.destination})' + +class MIPSLoadNode(MIPSDataTransferNode): + def __init__(self, destination, source): + self.destination = destination + self.source = source + +class MIPSLoadUpperInmediateNode(MIPSLoadNode): + pass + +class MIPSLoadAdressNode(MIPSLoadNode): + def __str__(self): + return f'la {self.destination}, {self.source}' + +class MIPSLoadInmediateNode(MIPSLoadNode): + def __str__(self): + return f'li {self.destination}, {str(self.source)}' + +class MIPSMoveFromNode(MIPSDataTransferNode): + def __init__(self, destination): + self.destination = destination + +class MIPSMoveNode(MIPSDataTransferNode): + def __init__(self, destination, source): + self.destination = destination + self.source = source + + def __str__(self): + return f"move {self.destination} {self.source}" + +class MIPSConditionalBranchNode(MIPSInstructionNode): + def __init__(self, r1, r2, jump): + self.r1 = r1 + self.r2 = r2 + self.jump = jump + +class MIPSBranchOnEqualNode(MIPSConditionalBranchNode): + def __str__(self): + return f"beq {self.r1}, {self.r2}, {self.jump}" + +class MIPSBranchNeqZero(MIPSInstructionNode): + def __init__(self, r, label): + self.r = r + self.label = label + + def __str__(self): + return f"bnez {self.r}, {self.label}" + +class MIPSBranchOnNotEqualNode(MIPSConditionalBranchNode): + def __str__(self): + return f"bne {self.r1}, {self.r2}, {self.jump}" + +class MIPSBranchOnGTNode(MIPSConditionalBranchNode): + def __str__(self): + return f"bgt {self.r1}, {self.r2}, {self.jump}" + +class MIPSBranchOnGTENode(MIPSConditionalBranchNode): + pass + +class MIPSBranchOnLTNode(MIPSConditionalBranchNode): + def __str__(self): + return f"blt {self.r1}, {self.r2}, {self.jump}" + +class MIPSBranchOnLTENode(MIPSConditionalBranchNode): + pass + +class MIPSComparissonNode(MIPSInstructionNode): + def __init__(self, result_register, value1, value2): + self.result_register = result_register + self.value1 = value1 + self.value2 = value2 + +class MIPSSetOnLTNode(MIPSComparissonNode): + def __str__(self): + return f'slt {self.result_register}, {self.value1}, {self.value2}' + +class MIPSSetOnLTENode(MIPSComparissonNode): + def __str__(self): + return f'sleu {self.result_register}, {self.value1}, {self.value2}' + +class MIPSSetOnENode(MIPSComparissonNode): + def __str__(self): + return f'seq {self.result_register}, {self.value1}, {self.value2}' + +class MIPSSetOnLTInmediateNode(MIPSComparissonNode): + def __str__(self): + return f'slti {self.result_register}, {self.value1}, {self.value2}' + +class MIPSUnconditionalJumpNode(MIPSInstructionNode): + def __init__(self, jump): + self.jump = jump + +class MIPSJumpNode(MIPSUnconditionalJumpNode): + def __str__(self): + return f"j {self.jump}" + +class MIPSJumpRegisterNode(MIPSUnconditionalJumpNode): + def __str__(self): + return f"jr {self.jump}" + +class MIPSJumpAndLinkNode(MIPSUnconditionalJumpNode): + def __str__(self): + return f"jal {self.jump}" + +class MIPSJumpAndLinkRegNode(MIPSInstructionNode): + def __init__(self, r): + self.r = r + + def __str__(self): + return f"jalr {self.r}" + +class MIPSLabelNode(MIPSInstructionNode): + def __init__(self, label): + self.label = label + + def __str__(self): + return f"{self.label}:" + +class MIPSEmptyInstruction(MIPSInstructionNode): + def __str__(self): + return "" + +class MIPSCommentNode(MIPSNode): + def __init__(self, comment): + self.comment = comment + + def __str__(self): + return f"#{self.comment}" + +class MIPSSyscallNode(MIPSInstructionNode): + def __str__(self): + return "syscall" + +class MIPSMLONode(MIPSInstructionNode): + def __init__(self,destiny): + self.destiny = destiny + def __str__(self): + return f"mflo {self.destiny}" diff --git a/src/compiler/components/generation/MIPS_generator.py b/src/compiler/components/generation/MIPS_generator.py new file mode 100644 index 00000000..9220cd02 --- /dev/null +++ b/src/compiler/components/generation/MIPS_generator.py @@ -0,0 +1,974 @@ +from compiler.utils.visitors_definitions import NodeVisitor +import compiler.components.generation.CIL_definitions as cil +from compiler.utils.config import * + + +class MipsVisitor(NodeVisitor): + def __init__(self, programContext): + super().__init__(programContext= programContext) + self.buffer= [] + self.type_index= [] + self.dispatchtable_code= [] + self.prototypes_code= [] + self.cur_labels_id = 0 + self.offset= {} + self.code = "" + + def push(self): + self.write_info('sw $a0 0($sp)') + self.write_info('addiu $sp $sp -4') + + def pop(self, dest=None): + self.write_info(f'addiu $sp $sp 4') + + def write_info(self, msg, tabbed= True): + info = "{}{}\n".format("\t" if tabbed else "", msg) + self.code += info + self.buffer.append(info) + + def allocate_memory(self, size=None, register=False): + if register: + self.write_info('move $a0 {}'.format(size)) + else: + if size: + self.write_info('li $a0 {}'.format(size)) + self.write_info('li $v0 9') + self.write_info('syscall') + + def new_labels_id(self): + self.cur_labels_id += 1 + return self.cur_labels_id + + def visit_Data(self, node: cil.Data): + self.write_info(f'{node.dest}: .align 2 \n \t\t\t.asciiz \"{str(node.value.encode())[2:-1]}\"') + + def visit_Program(self, node: cil.Program): + #-------------------- DATA SECTION ---------------------------- + + self.write_info('.data', tabbed= False) + self.static_datas() + + for data in node.data_section: + self.visit(data) + + self.write_info('') + for i in range(len(node.type_section)): + self.type_index.append(node.type_section[i].type_name) + self.write_info('classname_{}: .align 2 \n\t\t\t.asciiz \"{}\"'.format(node.type_section[i].type_name, + node.type_section[i].type_name)) + + self.write_info(f'type_void: .align 2 \n\t\t\t .asciiz \"\"') + + #-------------------- TEXT SECTION ---------------------------- + + self.write_info('\n.text', tabbed= False) + self.entrypoint() + + for t in node.type_section: + self.visit(t) + + self.write_info('\n########## STATIC FUNCTIONS ##########\n') + # CONFORMS + self.conforms() + # IS_VOID + self.isvoid() + # OBJECT + self.object_abort() + self.object_copy() + self.object_typename() + # STRING + self.string_length() + self.string_concat() + self.string_substr() + # IO + self.io_in_int() + self.io_in_string() + self.io_out_int() + self.io_out_string() + + self.write_info('\n############## TABLES ################\n') + # Generate method that creates classes's name table + self.write_info('function_build_class_name_table:', tabbed=False) + self.allocate_memory(len(node.type_section) * 4) + self.write_info('move $s1 $v0') # save the address of the table in a register + for i in range(len(node.type_section)): + self.write_info('la $t1 classname_{}'.format(node.type_section[i].type_name)) + self.write_info('sw $t1 {}($s1)'.format(4 * i)) + self.write_info('jr $ra') + self.write_info('') + + # Generate method that allocates memory for prototypes table + self.write_info('function_allocate_prototypes_table:', tabbed=False) + self.allocate_memory(8 * len(self.type_index)) + self.write_info('move $s0 $v0') # save the address of the table in a register + self.write_info('jr $ra') + self.write_info('') + + # Generate mips method that builds prototypes + self.write_info('function_build_prototypes:', tabbed=False) + for ins in self.prototypes_code: + self.write_info(ins) + self.write_info('jr $ra') + self.write_info('') + + # Generate mips method that builds dispatch tables + self.write_info('function_build_dispatch_tables:', tabbed=False) + for ins in self.dispatchtable_code: + self.write_info(ins) + self.write_info('jr $ra') + self.write_info('') + + # Generate method that builds class parents table + self.write_info('function_build_class_parents_table:', tabbed=False) + self.allocate_memory(4 * len(self.type_index)) + self.write_info('move $s2 $v0') # save the address of the table in a register + self.write_info('') + + # Fill table entry for each class type + for parent in node.type_section: + if parent.type_name != 'void': + p_index = self.type_index.index(parent.type_name) + for child in self.programContext.types[parent.type_name].children: + ch_index = self.type_index.index(child) + self.write_info(f'li $t0 {ch_index}') + self.write_info(f'mul $t0 $t0 4') + self.write_info(f'add $t0 $t0 $s2') + self.write_info(f'li $t1 {p_index}') + self.write_info(f'sw $t1 0($t0)') + self.write_info('') + + self.write_info('jr $ra') + self.write_info('') + + + # Generate COOL functions + self.write_info('\n########### COOL FUNCTIONS ##########\n') + for func in node.code_section: + is_built_in = False + if not '__init' in func.name: + is_built_in = [x for x in self.programContext.basics if f'{x}_' in func.name] != [] + if not is_built_in: + self.visit(func) + self.write_info('\n#####################################\n') + return self.buffer + + + + def visit_Function(self, node: cil.Function): + self.code = "" + self.write_info(f'function_{node.name}:', tabbed=False) + + # Set up stack frame + self.write_info(f'move $fp, $sp') + self.write_info(f'subu $sp, $sp, {4 * len(node.vlocals)}') + + # Register arguments offsets + for i in range(len(node.args)): + self.offset[node.args[i].name] = 12 + i * 4 + + # Register locals offsets + for i in range(len(node.vlocals)): + self.offset[node.vlocals[i].name] = i * (-4) + + # Generate mips code for the function's body + for inst in node.body: + # Equal node needs unique id for its labels + if isinstance(inst, cil.Equal) or isinstance(inst, cil.Div): + inst.id = self.new_labels_id() + + self.visit(inst) + + # Pop the stack frame + self.write_info(f'addiu $sp, $sp, {4 * len(node.vlocals)}') + + # Return + self.write_info('jr $ra') + self.write_info('') + + def visit_PushParam(self, node: cil.PushParam): + self.write_info('# PUSHPARAM') + if node.name[0] != "_": + self.write_info('li $a0, {}'.format(self.type_index.index(node.name))) + else: + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.name])) + self.push() + self.write_info('') + + + def visit_PopParam(self, node: cil.PopParam): + self.write_info('# POPPARAM') + self.pop(node.name) + self.write_info('') + + def visit_Return(self, node: cil.Return): + self.write_info('# RETURN') + self.write_info('lw $v0, {}($fp)'.format(self.offset[node.value])) + + def visit_Call(self, node: cil.Call): + self.write_info('# CALL') + + # Save return address and frame pointer + self.write_info(f'addiu $sp, $sp, -8') + self.write_info(f'sw $ra, 4($sp)') + self.write_info(f'sw $fp, 8($sp)') + + # Call the function + self.write_info(f'jal function_{node.f}') + + # Restore return address and frame pointer + self.write_info(f'lw $fp, 8($sp)') + self.write_info(f'lw $ra, 4($sp)') + self.write_info(f'addiu $sp, $sp, 8') + + if node.dest: + self.write_info(f'sw $v0 {self.offset[node.dest]}($fp)') + + self.write_info('') + + def visit_GetAttrib(self, node: cil.GetAttrib): + self.write_info('# GETATTR') + self.write_info(f'lw $a1 {self.offset[node.instance]}($fp)') + self.write_info(f'lw $a0 {12 + 4 * node.attribute}($a1)') + self.write_info(f'sw $a0 {self.offset[node.dest]}($fp)') + self.write_info('') + + def visit_Allocate(self, node: cil.Allocate): + self.write_info('# ALLOCATE') + if node.ttype == 'void': + self.write_info(f'la $v0 type_void') + self.write_info(f'sw $v0 {self.offset[node.dest]}($fp)') + else: + offset_proto = self.type_index.index(node.ttype) * 8 + self.write_info('lw $t0 {}($s0)'.format(offset_proto)) + self.write_info('sw $t0, 0($sp)') + self.write_info('addiu $sp, $sp, -4') + self.write_info('') + self.visit(cil.Call(dest = node.dest, f = "Object_copy")) + self.write_info('addiu $sp, $sp, 4') + self.write_info('') + + + def visit_SetAttrib(self, node: cil.SetAttrib): + self.write_info('# SETATTR') + self.write_info(f'lw $a1 {self.offset[node.instance]}($fp)') + if isinstance(node.src, int): + self.write_info(f'li $a0, {node.src}') + elif node.src[:5] == "data_": + self.write_info(f'la $a0, {node.src}') + else: + self.write_info(f'lw $a0 {self.offset[node.src]}($fp)') + self.write_info(f'sw $a0 {12 + 4 * node.attribute}($a1)') + self.write_info('') + + def visit_TypeOf(self, node: cil.TypeOf): + self.write_info('# TYPEOF') + self.write_info(f'lw $a1 {self.offset[node.instance]}($fp)') + self.write_info(f'lw $a0 0($a1)') + self.write_info(f'sw $a0 {self.offset[node.dest]}($fp)') + self.write_info('') + + def visit_VCall(self, node: cil.VCall): + self.write_info('# VCALL') + + # Save return address and frame pointer + self.write_info(f'addiu $sp, $sp, -8') + self.write_info(f'sw $ra, 4($sp)') + self.write_info(f'sw $fp, 8($sp)') + + if node.ttype[0] == "_": + # If node.type is a local CIL variable + self.write_info(f'lw $a2, {self.offset[node.ttype]}($fp)') + else: + # If node.type a type name + self.write_info(f'li $a2, {self.type_index.index(node.ttype)}') + self.write_info(f'mul $a2, $a2, 8') + self.write_info(f'addu $a2, $a2, $s0') + self.write_info(f'lw $a1, 0($a2)') + + # Check the dispatch table for the method's address + self.write_info(f'lw $a2, 8($a1)') + self.write_info(f'lw $a0 {node.f * 4}($a2)') + + # Call the function at 0($a0) + self.write_info(f'jalr $a0') + + # Restore return address and frame pointer + self.write_info(f'lw $fp, 8($sp)') + self.write_info(f'lw $ra, 4($sp)') + self.write_info(f'addiu $sp, $sp, 8') + + # Save value after restoring $fp + self.write_info(f'sw $v0 {self.offset[node.dest]}($fp)') + + # Check prototypes table for the dynamic type + if node.ttype[0] != '_': + self.write_info(f'li $a2, {self.type_index.index(node.ttype)}') + else: + self.write_info(f'lw $a2, {self.offset[node.ttype]}($fp)') + + self.write_info('') + + + def visit_Type(self, node: cil.Type): + # Allocate + self.dispatchtable_code.append(f'# Type {node.type_name}') + self.dispatchtable_code.append('li $a0 {}'.format(4 * len(node.methods))) + self.dispatchtable_code.append('li $v0 9') + self.dispatchtable_code.append('syscall') + + # Add dispatch table code + for i in range(len(node.methods)): + self.dispatchtable_code.append('la $t1 function_{}'.format(node.methods[i].function_name)) + self.dispatchtable_code.append('sw $t1 {}($v0)'.format(4 * i)) + self.dispatchtable_code.append('lw $t0 {}($s0)'.format(8 * self.type_index.index(node.type_name))) + self.dispatchtable_code.append('sw $v0 8($t0)') + self.dispatchtable_code.append('') + + # Allocate + self.prototypes_code.append(f'# Type {node.type_name}') + self.prototypes_code.append('li $a0 {}'.format(12 + 4 * len(node.attributes))) + self.prototypes_code.append('li $v0 9') + self.prototypes_code.append('syscall') + + # Add prototype code + class_index = self.type_index.index(node.type_name) + self.prototypes_code.append('li $a0 {}'.format(class_index)) + self.prototypes_code.append('sw $a0 0($v0)') + self.prototypes_code.append('li $a0 {}'.format(12 + 4 * len(node.attributes))) + self.prototypes_code.append('sw $a0 4($v0)') + self.prototypes_code.append('sw $v0 {}($s0)'.format(8 * class_index)) + self.prototypes_code.append('') + +####################### STATIC FUNCTIONS ####################### + + #----- STATIC DATAs + + def static_datas(self): + # Buffer for reading strings + self.write_info('str_buffer: .space 1024') + self.write_info('') + + # Declare error mensages + self.write_info('_index_negative_msg: .align 2 \n\t\t\t .asciiz \"Index to substr is negative\\n\"') + self.write_info('_index_out_msg: .align 2 \n\t\t\t .asciiz \"Index out range exception\\n\"') + self.write_info('_abort_msg: .align 2 \n\t\t\t .asciiz \"Execution aborted\\n\"') + self.write_info('_div_zero_msg: .align 2 \n\t\t\t .asciiz \"Division by zero exception\\n\"') + + self.write_info('') + + def entrypoint(self): + self.write_info('main:', tabbed=False) + self.visit(cil.Call(dest = None, f = 'build_class_name_table')) + self.visit(cil.Call(dest = None, f = 'allocate_prototypes_table')) + self.visit(cil.Call(dest = None, f = 'build_prototypes')) + self.visit(cil.Call(dest = None, f = 'build_dispatch_tables')) + self.visit(cil.Call(dest = None, f = 'build_class_parents_table')) + self.visit(cil.Allocate(dest = None, ttype = 'Main')) + + # Push main self + self.write_info('sw $v0 0($sp)') + self.write_info('addiu $sp $sp -4') + + self.visit(cil.Call(dest = None, f = f'Main__init')) + self.write_info('addiu $sp $sp 4') + + # Push main self + self.write_info('sw $v0 0($sp)') + self.write_info('addiu $sp $sp -4') + + self.visit(cil.Call(dest = None, f = 'Main_main')) + self.write_info('addiu $sp $sp 4') + + self.write_info('li $v0 10') + self.write_info('syscall') + + + #----- OBJECT METHODS + + def object_abort(self): + self.write_info('function_Object_abort:', tabbed=False) + # Set up stack frame + self.write_info('move $fp, $sp') + + # Aborting + self.write_info('li $v0 10') + self.write_info('syscall') + self.write_info('') + + def object_copy(self): + self.write_info('function_Object_copy:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.write_info('lw $t0 12($fp)')# recoger la instancia a copiar + self.write_info('lw $a0 4($t0)') + self.write_info('move $t4 $a0') + self.write_info('li $v0 9') + self.write_info('syscall')# guarda en v0 la direccion de memoria que se reservo + self.write_info('move $t2 $v0')# salvar la direccion donde comienza el objeto + self.write_info('li $t3 0') # size ya copiado + self.write_info('_objcopy_loop:', tabbed=False) + self.write_info('lw $t1 0($t0)') # cargar la palabra por la que voy + self.write_info('sw $t1 0($v0)') # copiar la palabra + self.write_info('addiu $t0 $t0 4') # posiciona el puntero en la proxima palabra a copiar + self.write_info('addiu $v0 $v0 4') # posiciona el puntero en la direccion donde copiar la proxima palabra + self.write_info('addiu $t3 $t3 4') # actualizar el size copiado + self.write_info('ble $t4 $t3 _objcopy_loop') # verificar si la condicion es igual o menor igual + self.write_info('_objcopy_div_end_:', tabbed=False) + self.write_info('move $v0 $t2') # dejar en v0 la direccion donde empieza el nuevo objeto + self.write_info('jr $ra') + self.write_info('') + + def object_typename(self): + self.write_info('function_Object_type_name:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + # Box the string reference + self.visit(cil.Allocate(dest = None, ttype = "String")) # Create new String object + self.write_info('move $v1 $v0') + + # Box string's length + self.visit(cil.Allocate(dest = None, ttype = "Int") ) # Create new Int object + + self.write_info('lw $a1 12($fp)') # self + self.write_info('lw $a1 0($a1)') + self.write_info('mul $a1 $a1 4') # self's class tag + self.write_info('addu $a1 $a1 $s1') # class name table entry address + self.write_info('lw $a1 0($a1)') # Get class name address + + self.write_info('move $a2 $0') # Compute string's length + self.write_info('move $t2 $a1') + self.write_info('_str_len_clsname_:', tabbed=False) + self.write_info('lb $a0 0($t2)') + self.write_info('beq $a0 $0 _end_clsname_len_') + self.write_info('addiu $a2 $a2 1') + self.write_info('addiu $t2 $t2 1') + self.write_info('j _str_len_clsname_') + self.write_info('_end_clsname_len_:', tabbed=False) + + self.write_info('sw $a2, 12($v0)') # Store string's length + + self.write_info('sw $v0, 12($v1)') # Fill String attributes + self.write_info('sw $a1, 16($v1)') + + self.write_info('move $v0 $v1') + self.write_info('jr $ra') + self.write_info('') + + + #----- STRING METHODS + + def string_length(self): + self.write_info('function_String_length:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.write_info('lw $a0 12($fp)') # Self + self.write_info('lw $v0 12($a0)') + self.write_info('jr $ra') + self.write_info('') + + def string_concat(self): + self.write_info('function_String_concat:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.visit(cil.Allocate(dest = None, ttype = "Int")) # Create new Int object + self.write_info('move $v1 $v0') # Save new Int Object + + self.visit(cil.Allocate(dest = None, ttype = "String")) # Create new String object + self.write_info('move $t3 $v0') # Store new String object + + self.write_info('lw $a1 12($fp)') # Self + self.write_info('lw $a2 16($fp)') # Boxed String to concat + + self.write_info('lw $t1 12($a1)') # Self's length Int object + self.write_info('lw $t1 12($t1)') # Self's length + + self.write_info('lw $t2 12($a2)') # strings to concat's length Int object + self.write_info('lw $t2 12($t2)') # strings to concat's length + + self.write_info('addu $t0 $t2 $t1') # New string's length + self.write_info('sw $t0 12($v1)') # Store new string's length into box + + self.write_info('lw $a1 16($a1)') # Unbox strings + self.write_info('lw $a2 16($a2)') + + self.write_info('addiu $t0 $t0 1') # Add space for \0 + self.allocate_memory('$t0', register=True) # Allocate memory for new string + self.write_info('move $t5 $v0') # Keep the string's reference in v0 and use t7 + + + # a1: self's string a2: 2nd string t1: length self t2: 2nd string length + # v1: new string's int object + + self.write_info('move $t4 $a1') # Index for iterating the self string + self.write_info('addu $a1 $a1 $t1') # self's copy limit + self.write_info('_strcat_copy_:', tabbed=False) + self.write_info('beq $t4 $a1 _end_strcat_copy_') # No more characters to copy + + self.write_info('lb $a0 0($t4)') # Copy the character + self.write_info('sb $a0 0($t5)') + + self.write_info('addiu $t5 $t5 1') # Advance indices + self.write_info('addiu $t4 $t4 1') + self.write_info('j _strcat_copy_') + self.write_info('_end_strcat_copy_:', tabbed=False) + + # Copy 2nd string + + self.write_info('move $t4 $a2') # Index for iterating the strings + self.write_info('addu $a2 $a2 $t2') # self's copy limit + self.write_info('_strcat_copy_snd_:', tabbed=False) + self.write_info('beq $t4 $a2 _end_strcat_copy_snd_') # No more characters to copy + + self.write_info('lb $a0 0($t4)') # Copy the character + self.write_info('sb $a0 0($t5)') + + self.write_info('addiu $t5 $t5 1') # Advance indices + self.write_info('addiu $t4 $t4 1') + self.write_info('j _strcat_copy_snd_') + self.write_info('_end_strcat_copy_snd_:', tabbed=False) + + self.write_info('sb $0 0($t5)') # End string with \0 + + # $v0: reference to new string $v1: length int object + # $t3: new string object + # -> Create boxed string + + self.write_info('sw $v1 12($t3)') # New length + self.write_info('sw $v0 16($t3)') # New string + + self.write_info('move $v0 $t3') # Return new String object in $v0 + self.write_info('jr $ra') + self.write_info('') + + def string_substr(self): + self.write_info('function_String_substr:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + self.write_info(f'lw $t5 12($fp)') # self param + self.write_info(f'lw $a1 16($fp)') # reference of object int that represent i + self.write_info(f'lw $a1 12($a1)') # value of i + self.write_info(f'lw $a2 20($fp)') # reference of object int that represent j + self.write_info(f'lw $a2 12($a2)') # value of j that is length to copy + self.write_info(f'blt $a1 $0 _index_negative') # index i is negative + self.write_info(f'blt $a2 $0 _index_negative') # length j is negative + self.write_info(f'add $a2 $a1 $a2') # finish index + self.write_info(f'lw $a3 12($t5)') + self.write_info(f'lw $a3 12($a3)') # length of string + self.write_info(f'bgt $a2 $a3 _index_out') # j > lenght + + # not errors + self.visit(cil.Allocate(dest = None, ttype = "String")) + self.write_info(f'move $v1 $v0') # new string + + self.visit(cil.Allocate(dest = None, ttype = "Int")) + self.write_info(f'move $t0 $v0') # lenght of string + self.write_info(f'move $t7 $a2') + self.write_info(f'subu $t7 $t7 $a1') + self.write_info(f'sw $t7 12($t0)') # save number that represent lenght of new string + + self.allocate_memory('$a2', register=True) # $v0 -> address of the string + + self.write_info(f'sw $t0 12($v1)') # store length + self.write_info(f'sw $v0 16($v1)') # store address of new string to String object + + # generate substring + self.write_info('move $t1 $v0') # Index for iterating the new string + + self.write_info('lw $t5 16($t5)') # Index for iterating the self string + self.write_info('move $t4 $t5') + self.write_info('addu $t4 $t4 $a1') # self's copy start + self.write_info('addu $t5 $t5 $a2') # self's copy limit + + self.write_info('_substr_copy_:', tabbed=False) + self.write_info('bge $t4 $t5 _end_substr_copy_') # No more characters to copy + + self.write_info('lb $a0 0($t4)') # Copy the character + self.write_info('sb $a0 0($t1)') + + self.write_info('addiu $t1 $t1 1') # Advance indices + self.write_info('addiu $t4 $t4 1') + self.write_info('j _substr_copy_') + + # errors sections + self.write_info(f'_index_negative:',tabbed=False) + self.write_info(f'la $a0 _index_negative_msg') + self.write_info(f'b _subst_abort') + + self.write_info(f'_index_out:',tabbed=False) + self.write_info(f'la $a0 _index_out_msg') + self.write_info(f'b _subst_abort') + + # abort execution + self.write_info(f'_subst_abort:',tabbed=False) + self.write_info(f'li $v0 4') + self.write_info(f'syscall') + self.write_info('la $a0 _abort_msg') + self.write_info(f'li $v0 4') + self.write_info(f'syscall') + self.write_info(f'li $v0 10') + self.write_info(f'syscall') # exit + + # successful execution + self.write_info('_end_substr_copy_:', tabbed=False) + + self.write_info('move $v0 $v1') + self.write_info('jr $ra') + self.write_info('') + + #----- IO + + def io_in_int(self): + self.write_info('function_IO_in_int:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.visit(cil.Allocate(dest = None, ttype = "Int")) # Create new Int object + + self.write_info('move $t0 $v0') # Save Int object + + self.write_info('li $v0 5') # Read int + self.write_info('syscall') + + self.write_info('sw $v0 12($t0)') # Store int + + self.write_info('move $v0 $t0') + self.write_info('jr $ra') + self.write_info('') + + def io_in_string(self): + self.write_info('function_IO_in_string:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.visit(cil.Allocate(dest = None, ttype = "Int")) # Create new Int object for string's length + self.write_info('move $v1 $v0') # $v1: Int pbject + + self.visit(cil.Allocate(dest = None, ttype = "String")) # Create new String object + self.write_info('sw $v1 12($v0)') + self.write_info('move $t5 $v0') # $t5: String object + + # Read String and store in a temp buffer + self.write_info('la $a0 str_buffer') + self.write_info('li $a1 1025') + self.write_info('li $v0 8') # Read string + self.write_info('syscall') + + # Compute string's length + self.write_info('move $a0 $0') + self.write_info('la $t2 str_buffer') + self.write_info('_in_string_str_len_:', tabbed=False) + self.write_info('lb $t0 0($t2)') + self.write_info('beq $t0 $0 _end_in_string_str_len_') + self.write_info('beq $t0 10 _end_in_string_str_len_') + self.write_info('addiu $a0 $a0 1') + self.write_info('addiu $t2 $t2 1') + self.write_info('j _in_string_str_len_') + self.write_info('_end_in_string_str_len_:', tabbed=False) + + # Store string's length into Integer class + self.write_info('sw $a0 12($v1)') + + # Allocate size in $a0 ... string's length + self.allocate_memory() + + # $a0: string's length $v0: string's new address $t5: String object + + # Copy string from buffer to new address + self.write_info('la $t4 str_buffer') # Index for iterating the string buffer + self.write_info('move $t1 $v0') # Index for iterating new string address + + self.write_info('_in_str_copy_:', tabbed=False) + self.write_info('lb $t0 0($t4)') # Load a character + self.write_info('beq $t0 $0 _end_in_str_copy_') # No more characters to copy + self.write_info('beq $t0 10 _end_in_str_copy_') # No more characters to copy + + self.write_info('sb $t0 0($t1)') # Copy the character + + self.write_info('addiu $t4 $t4 1') # Advance indices + self.write_info('addiu $t1 $t1 1') + self.write_info('j _in_str_copy_') + self.write_info('_end_in_str_copy_:', tabbed=False) + + # Store string + self.write_info('sw $v0 16($t5)') + + # Clean string buffer + self.write_info('la $t4 str_buffer') # Index for iterating the string buffer + self.write_info('_in_str_clean_:', tabbed=False) + self.write_info('lb $t0 0($t4)') # Load a character + self.write_info('beq $t0 $0 _end_in_str_clean_') # No more characters to clean + + self.write_info('sb $0 0($t4)') # Clean the character + + self.write_info('addiu $t4 $t4 1') # Advance indices + self.write_info('j _in_str_clean_') + self.write_info('_end_in_str_clean_:', tabbed=False) + + # Return new string in $v0 + self.write_info('move $v0 $t5') + self.write_info('jr $ra') + self.write_info('') + + def io_out_int(self): + self.write_info('function_IO_out_int:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.write_info('lw $a0 16($fp)') # Get Int object + self.write_info('lw $a0 12($a0)') + + self.write_info('li $v0 1') # Print int + self.write_info('syscall') + + self.write_info('lw $v0 12($fp)') # Return self + self.write_info('jr $ra') + self.write_info('') + + def io_out_string(self): + self.write_info('function_IO_out_string:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.write_info('lw $a0 16($fp)') # Get String object + self.write_info('lw $a0 16($a0)') + + self.write_info('li $v0 4') # Print string + self.write_info('syscall') + + self.write_info('lw $v0 12($fp)') # Return self + self.write_info('jr $ra') + self.write_info('') + + #------ CONFORMS + + def conforms(self): + self.write_info(f'function___conforms:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.write_info(f'lw $t0 12($fp)') # First arg's class tag + self.write_info(f'lw $t1 16($fp)') # Second arg's class tag + + # 2nd arg == Object -> return true + self.write_info(f'beq $t1 {self.type_index.index("Object")} _conforms_ret_true_') + + self.write_info('_conforms_loop_:', tabbed=False) + + # current == 2nd arg -> return true + self.write_info('beq $t0 $t1 _conforms_ret_true_') + + # current == Object -> return false + self.write_info(f'beq $t0 {self.type_index.index("Object")} _conforms_ret_false_') + + # Query parents's class tag from $s2 ... class parent table + self.write_info('mul $t0 $t0 4') + self.write_info('addu $t0 $t0 $s2') + self.write_info('lw $t0 0($t0)') # current = current.parent + self.write_info('j _conforms_loop_') + + self.write_info('_conforms_ret_true_:', tabbed=False) + self.write_info('li $v0 1') + self.write_info('j _conforms_ret_') + + self.write_info('_conforms_ret_false_:', tabbed=False) + self.write_info('li $v0 0') + + # No need to store result in a Bool class + self.write_info('_conforms_ret_:') + self.write_info('jr $ra') + self.write_info('') + + #------ ISVOID + + def isvoid(self): + self.write_info(f'function__isvoid:', tabbed=False) + # Set up stack frame + self.write_info(f'move $fp, $sp') + + self.visit(cil.Allocate(dest = None, ttype = "Bool")) + # $v0 contains new Bool object + + self.write_info(f'lw $t0 12($fp)') # 1st arg is an object address + self.write_info(f'la $t1 type_void') + + self.write_info(f'beq $t0 $t1 _is_void_true_') # arg == void type + self.write_info(f'sw $0 12($v0)') # return False + self.write_info(f'j _is_void_end_') + + self.write_info(f'_is_void_true_:', tabbed=False) + self.write_info(f'li $t0 1') + self.write_info(f'sw $t0 12($v0)') # return True + self.write_info(f'_is_void_end_:', tabbed=False) + + # Return Bool object in $v0 + self.write_info(f'jr $ra') + self.write_info(f'') + +############################# COMPARISONS #################################### + + def visit_Equal(self, node: cil.Equal): + self.write_info('lw $t0 {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $t1 {}($fp)'.format(self.offset[node.right])) + self.write_info(f'beq $t0 $zero _eq_false_{node.id}_') # $t0 can't also be void + self.write_info(f'beq $t1 $zero _eq_false_{node.id}_') # $t1 can't also be void + self.write_info('lw $a0 0($t0)') # get object 1 tag + self.write_info('lw $a1 0($t1)') # get object 2 tag + self.write_info(f'bne $a0 $a1 _eq_false_{node.id}_') # compare tags + self.write_info('li $a2 {}'.format(self.type_index.index("Int"))) # load int tag + self.write_info(f'beq $a0 $a2 _eq_int_bool_{node.id}') # Integers + self.write_info('li $a2 {}'.format(self.type_index.index("Bool"))) # load bool tag + self.write_info(f'beq $a0 $a2 _eq_int_bool_{node.id}') # Booleans + self.write_info('li $a2 {}'.format(self.type_index.index("String"))) # load string tag + self.write_info(f'bne $a0 $a2 _not_basic_type_{node.id}_') # Not a primitive type + + # equal strings + # verify len of the strings + self.write_info(f'_eq_str_{node.id}_:', tabbed = False) # handle strings + self.write_info('lw $t3 12($t0)') # get string_1 size + self.write_info('lw $t3 12($t3)') # unbox string_1 size + self.write_info('lw $t4, 12($t1)') # get string_2 size + self.write_info('lw $t4, 12($t4)') # unbox string_2 size + self.write_info(f'bne $t3 $t4 _eq_false_{node.id}_') # string size are distinct + self.write_info(f'beq $t3 $0 _eq_true_{node.id}_') # if strings are empty + + # Verify ascii secuences + self.write_info('addu $t0 $t0 16') # Point to start of string s1 + self.write_info('lw $t0 0($t0)') + self.write_info('addu $t1 $t1 16') # Point to start of string s2 + self.write_info('lw $t1 0($t1)') + self.write_info('move $t2 $t3') # Keep string length as counter + self.write_info(f'_verify_ascii_sequences_{node.id}_:', tabbed = False) + self.write_info('lb $a0 0($t0)') # get char of s1 + self.write_info('lb $a1 0($t1)') # get char of s2 + self.write_info(f'bne $a0 $a1 _eq_false_{node.id}_') # char s1 /= char s2 + self.write_info('addu $t0 $t0 1') + self.write_info('addu $t1 $t1 1') + self.write_info('addiu $t2 $t2 -1') # Decrement counter + self.write_info(f'bnez $t2 _verify_ascii_sequences_{node.id}_') + self.write_info(f'b _eq_true_{node.id}_') # end of strings + + self.write_info(f'_not_basic_type_{node.id}_:', tabbed = False) + self.write_info(f'bne $t0 $t1 _eq_false_{node.id}_') + self.write_info(f'b _eq_true_{node.id}_') + + # equal int or boolf + self.write_info(f'_eq_int_bool_{node.id}:', tabbed = False) # handles booleans and ints + self.write_info('lw $a3 12($t0)') # load value variable_1 + self.write_info('lw $t4 12($t1)') # load variable_2 + self.write_info(f'bne $a3 $t4 _eq_false_{node.id}_') # value of int or bool are distinct + + #return true + self.write_info(f'_eq_true_{node.id}_:', tabbed = False) + self.write_info('li $a0 1') + self.write_info('sw $a0 {}($fp)'.format(self.offset[node.dest])) + self.write_info(f'b end_equal_{node.id}_') + + #return false + self.write_info(f'_eq_false_{node.id}_:', tabbed = False) + self.write_info('li $a0 0') + self.write_info('sw $a0 {}($fp)'.format(self.offset[node.dest])) + self.write_info(f'end_equal_{node.id}_:', tabbed = False) + + + def visit_EqualOrLessThan(self, node: cil.EqualOrLessThan): + self.write_info('# <=') + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a2, {}($fp)'.format(self.offset[node.right])) + self.write_info('sle $a0, $a1, $a2'.format(self.offset[node.right])) + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + def visit_LessThan(self, node: cil.LessThan): + self.write_info('# <') + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a2, {}($fp)'.format(self.offset[node.right])) + self.write_info('slt $a0, $a1, $a2'.format(self.offset[node.right])) + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + def visit_Goto(self, node: cil.Goto): + self.write_info('# GOTO') + self.write_info('j _cil_label_{}'.format(node.label)) + self.write_info('') + + def visit_IfGoto(self, node: cil.IfGoto): + self.write_info('# IF GOTO') + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.condition])) + self.write_info('bnez $a0, _cil_label_{}'.format(node.label)) + self.write_info('') + +############################## ASSIGNMENT #################################### + + def visit_Assign(self, node: cil.Assign): + self.write_info('# ASSIGN') + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.source])) + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + def visit_Label(self, node: cil.Label): + self.write_info('_cil_label_{}:'.format(node.name), tabbed=False) + +############################# ARITHMETICS #################################### + + def visit_Plus(self, node: cil.Plus): + self.write_info('# +') + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.right])) + self.write_info('add $a0, $a0, $a1') + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + + def visit_Minus(self, node: cil.Minus): + self.write_info('# -') + if isinstance(node.left, int): + self.write_info('li $a0 {}'.format(node.left)) + else: + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.right])) + self.write_info('sub $a0, $a0, $a1') + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + def visit_Mult(self, node: cil.Mult): + self.write_info('# *') + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.right])) + self.write_info('mul $a0, $a0, $a1') + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + + def visit_Div(self, node: cil.Div): + self.write_info('# /') + self.write_info('lw $a0, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.right])) + self.write_info(f'beqz $a1 _div_error_{node.id}_') + self.write_info('div $a0, $a0, $a1') + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info(f'b _div_end_{node.id}_') + self.write_info(f'_div_error_{node.id}_:',tabbed=False) + self.write_info('la $a0 _div_zero_msg') + self.write_info('li $v0 4') + self.write_info('syscall') + self.write_info('la $a0 _abort_msg') + self.write_info('li $v0 4') + self.write_info('syscall') + self.write_info('li $v0 10') + self.write_info('syscall') + self.write_info(f'_div_end_{node.id}_:',tabbed=False) + + +############################# COMPARISONS #################################### + + def visit_LessThan(self, node: cil.LessThan): + self.write_info('# <') + self.write_info('lw $a1, {}($fp)'.format(self.offset[node.left])) + self.write_info('lw $a2, {}($fp)'.format(self.offset[node.right])) + self.write_info('slt $a0, $a1, $a2'.format(self.offset[node.right])) + self.write_info('sw $a0, {}($fp)'.format(self.offset[node.dest])) + self.write_info('') + diff --git a/src/compiler/components/generation/__init__.py b/src/compiler/components/generation/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/generation/context.py b/src/compiler/components/generation/context.py new file mode 100644 index 00000000..bdd9645d --- /dev/null +++ b/src/compiler/components/generation/context.py @@ -0,0 +1,23 @@ + + +class NameMap: + def __init__(self, parent=None): + self.namemap = {} + self.parent = parent + + def define_variable(self, coolname, cilname): + self.namemap[coolname] = cilname + + def create_child_scope(self): + child_scope = NameMap(self) + return child_scope + + def exit_child_scope(self): + self.namemap = self.parent.namemap + self.parent = self.parent.parent + + def get_cil_name(self, coolname): + if not coolname in self.namemap.keys(): + return self.parent.get_cil_name(coolname) if self.parent else None + else: + return self.namemap[coolname] \ No newline at end of file diff --git a/src/compiler/components/lexer/__init__.py b/src/compiler/components/lexer/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/lexer/lexer_analyzer.py b/src/compiler/components/lexer/lexer_analyzer.py new file mode 100644 index 00000000..4a3d1ba8 --- /dev/null +++ b/src/compiler/components/lexer/lexer_analyzer.py @@ -0,0 +1,233 @@ +import ply.lex as lex +from ply.lex import Token +from ply.lex import TOKEN +from compiler.utils.errors import error + +tokens = [ + # Identifiers + "ID", "TYPE", + + # Primitive Types + "INTEGER", "STRING", "BOOLEAN", + + # Literals + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "COLON", "COMMA", "DOT", "SEMICOLON", "AT", + + # Operators + "PLUS", "MINUS", "MULTIPLY", "DIVIDE", "EQ", "LT", "LTEQ", "ASSIGN", "INT_COMP", + + # Special Operators + "ARROW" +] + +reserved = { + 'new':'NEW', + 'of':'OF', + 'if' : 'IF', + 'let':'LET', + 'in' : 'IN', + 'fi':'FI', + 'else' : 'ELSE', + 'while':'WHILE', + 'case':'CASE', + 'then' : 'THEN', + 'esac':'ESAC', + 'pool':'POOL', + 'class':'CLASS', + 'loop':'LOOP', + 'inherits':'INHERITS', + 'isvoid':'ISVOID', + "not": "NOT" +} + +tokens += list(reserved.values()) + +#Simple rules +t_PLUS = r'\+' +t_MINUS = r'\-' +t_MULTIPLY = r'\*' +t_DIVIDE = r'\/' +t_LPAREN = r'\(' +t_RPAREN = r'\)' +t_EQ = r'\=' +t_LT = r'\<' +t_LTEQ = r'\<\=' +t_ASSIGN = r'\<\-' +t_INT_COMP = r'~' +t_LBRACE = r'\{' +t_RBRACE = r'\}' +t_COLON = r'\:' +t_COMMA = r'\,' +t_DOT = r'\.' +t_SEMICOLON = r'\;' +t_AT = r'\@' +t_ARROW = r'\=\>' +#complex rules + +@TOKEN(r"(t[R|r][U|u][e|E]|f[a|A][l|L][s|S][e|E])") +def t_BOOLEAN(token): + token.value = token.value.lower() + return token + +@TOKEN(r"\d+") +def t_INTEGER(token): + token.value = int(token.value) + return token + +@TOKEN(r"[A-Z][A-Za-z0-9_]*") +def t_TYPE(token): + token.type = reserved.get(token.value.lower(), 'TYPE') + return token + +@TOKEN(r"[a-z][A-Za-z0-9_]*") +def t_ID(token): + token.type = reserved.get(token.value.lower(), "ID") + return token + +# Utility definitions +@TOKEN(r'\n+') +def t_newline(t): + global readjust_col + readjust_col = t.lexpos + len(t.value) + t.lexer.lineno += len(t.value) + +def t_error(token): + global readjust_col + errors.append(error(error_type="LexicographicError", row_and_col= (token.lineno, token.lexpos - readjust_col + 1), message='ERROR "%s"' % (token.value[:1]))) + token.lexer.skip(1) + +t_ignore = ' \t' +t_ignore_COMMENTLINE = r"\-\-[^\n]*" + + +#Global states +states = ( + ("STRING", "exclusive"), + ("COMMENT", "exclusive") +) + +#The string states +@TOKEN(r'\"') +def t_start_string(token): + token.lexer.push_state("STRING") + token.lexer.string_backslashed = False + token.lexer.stringbuf = "" + +@TOKEN(r'\n') +def t_STRING_newline(token): + global readjust_col + token.lexer.lineno += 1 + if not token.lexer.string_backslashed: + errors.append(error(error_type="LexicographicError", row_and_col= (token.lineno, token.lexpos - readjust_col + 1), + message= "Unterminated string constant")) + token.lexer.pop_state() + else: + token.lexer.string_backslashed = False + readjust_col = token.lexpos + len(token.value) + +@TOKEN('\0') +def t_STRING_null(token): + errors.append(error(error_type="LexicographicError", row_and_col= (token.lineno, token.lexpos - readjust_col + 1), message='Null character in string')) + token.lexer.skip(1) + +@TOKEN(r'\"') +def t_STRING_end(token): + if not token.lexer.string_backslashed: + token.lexer.pop_state() + token.value = token.lexer.stringbuf + token.type = "STRING" + return token + else: + token.lexer.stringbuf += '"' + token.lexer.string_backslashed = False + +@TOKEN(r"[^\n]") +def t_STRING_anything(token): + if token.lexer.string_backslashed: + if token.value == 'b': + token.lexer.stringbuf += '\b' + elif token.value == 't': + token.lexer.stringbuf += '\t' + elif token.value == 'n': + token.lexer.stringbuf += '\n' + elif token.value == 'f': + token.lexer.stringbuf += '\f' + elif token.value == '\\': + token.lexer.stringbuf += '\\' + else: + token.lexer.stringbuf += token.value + token.lexer.string_backslashed = False + else: + if token.value != '\\': + token.lexer.stringbuf += token.value + else: + token.lexer.string_backslashed = True + +def t_STRING_error(token): + token.lexer.skip(1) + errors.append(error(error_type="LexicographicError", + row_and_col= (token.lineno, token.lexpos - readjust_col + 1), + message= 'ERROR at or near ')) + +def t_STRING_eof(token): + errors.append(error(error_type="LexicographicError", row_and_col= (token.lineno, token.lexpos - readjust_col + 1), message='EOF in string constant')) + token.lexer.pop_state() + +t_STRING_ignore = '' + +# The comment state + +@TOKEN(r"\(\*") +def t_start_comment(token): + token.lexer.push_state("COMMENT") + token.lexer.comment_count = 0 + +@TOKEN(r"\(\*") +def t_COMMENT_startanother(token): + token.lexer.comment_count += 1 + +@TOKEN(r"\n+") +def t_COMMENT_newline(token): + global readjust_col + readjust_col = token.lexpos + len(token.value) + token.lexer.lineno += len(token.value) + +@TOKEN(r"\*\)") +def t_COMMENT_end(token): + if token.lexer.comment_count == 0: + token.lexer.pop_state() + else: + token.lexer.comment_count -= 1 + + +def t_COMMENT_error(token): + token.lexer.skip(1) + +def t_COMMENT_eof(token): + global readjust_col + errors.append(error(error_type="LexicographicError", row_and_col= (token.lineno, token.lexpos - readjust_col + 1), message= "EOF in comment")) + token.lexer.pop_state() + +t_COMMENT_ignore = '' +errors = [] + +def find_column(_input, token): + line_start = _input.rfind('\n', 0, token.lexpos) + 1 + return (token.lexpos - line_start) + 1 + +lexer = lex.lex() +def tokenizer(stream_input): + global readjust_col + readjust_col = 0 + lexer.input(stream_input) + token_list = [] + lexer.lineno= 1 + #lexer.lexpos= 1 + real_col = {} + for tok in lexer: + real_col.update({ str(tok): find_column(stream_input, tok) }) + token_list.append(tok) + + + return errors, token_list, real_col + diff --git a/src/compiler/components/parser/__init__.py b/src/compiler/components/parser/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/parser/parsetab.py b/src/compiler/components/parser/parsetab.py new file mode 100644 index 00000000..dd58bcd5 --- /dev/null +++ b/src/compiler/components/parser/parsetab.py @@ -0,0 +1,86 @@ + +# parsetab.py +# This file is automatically generated. Do not edit. +# pylint: disable=W,C,R +_tabversion = '3.10' + +_lr_method = 'LALR' + +_lr_signature = 'rightASSIGNrightNOTnonassocLTEQLTEQleftPLUSMINUSleftMULTIPLYDIVIDErightISVOIDrightINT_COMPleftATleftDOTARROW ASSIGN AT BOOLEAN CASE CLASS COLON COMMA DIVIDE DOT ELSE EQ ESAC FI ID IF IN INHERITS INTEGER INT_COMP ISVOID LBRACE LET LOOP LPAREN LT LTEQ MINUS MULTIPLY NEW NOT OF PLUS POOL RBRACE RPAREN SEMICOLON STRING THEN TYPE WHILE\n program : class_list\n \n class_list : class_list class SEMICOLON\n | class SEMICOLON\n \n class : CLASS TYPE LBRACE features_list_opt RBRACE\n \n class : CLASS TYPE INHERITS TYPE LBRACE features_list_opt RBRACE\n \n features_list_opt : features_list\n | empty\n \n features_list : features_list feature SEMICOLON\n | feature SEMICOLON\n \n feature : ID LPAREN formal_params_list RPAREN COLON TYPE LBRACE expression RBRACE\n \n feature : ID LPAREN RPAREN COLON TYPE LBRACE expression RBRACE\n \n feature : ID COLON TYPE ASSIGN expression\n \n feature : ID COLON TYPE\n \n formal_params_list : formal_params_list COMMA formal_param\n | formal_param\n \n formal_param : ID COLON TYPE\n \n expression : ID\n \n expression : INTEGER\n \n expression : BOOLEAN\n \n expression : STRING\n \n expression : LBRACE block_list RBRACE\n \n block_list : block_list expression SEMICOLON\n | expression SEMICOLON\n \n expression : ID ASSIGN expression\n \n expression : NEW TYPE\n \n expression : ISVOID expression\n \n expression : INT_COMP expression\n \n expression : NOT expression\n \n expression : expression PLUS expression\n | expression MINUS expression\n | expression MULTIPLY expression\n | expression DIVIDE expression\n \n expression : expression LT expression\n | expression LTEQ expression\n | expression EQ expression\n \n expression : LPAREN expression RPAREN\n \n expression : IF expression THEN expression ELSE expression FI\n \n expression : WHILE expression LOOP expression POOL\n \n expression : let_expression\n \n let_expression : LET nested_lets IN expression\n \n nested_lets : ID COLON TYPE\n | nested_lets COMMA ID COLON TYPE\n \n nested_lets : ID COLON TYPE ASSIGN expression\n | nested_lets COMMA ID COLON TYPE ASSIGN expression\n \n expression : CASE expression OF actions_list ESAC\n \n actions_list : actions_list action\n | action\n \n action : ID COLON TYPE ARROW expression SEMICOLON\n \n expression : expression DOT ID LPAREN arguments_list_opt RPAREN\n \n arguments_list_opt : arguments_list\n | empty\n \n arguments_list : arguments_list COMMA expression\n | expression\n \n expression : expression AT TYPE DOT ID LPAREN arguments_list_opt RPAREN\n \n expression : ID LPAREN arguments_list_opt RPAREN\n \n empty :\n ' + +_lr_action_items = {'CLASS':([0,2,6,8,],[4,4,-3,-2,]),'$end':([1,2,6,8,],[0,-1,-3,-2,]),'SEMICOLON':([3,5,14,17,18,28,35,40,41,42,43,44,53,70,71,72,73,74,83,88,89,90,91,92,93,94,97,98,100,108,109,119,122,127,128,133,140,143,144,],[6,8,19,-4,23,-13,-5,-17,-12,-18,-19,-20,-39,99,-25,-26,-27,-28,-24,-29,-30,-31,-32,-33,-34,-35,-21,113,-36,-11,-55,-40,-10,-38,-45,-49,-37,-54,146,]),'TYPE':([4,10,21,30,33,37,46,68,106,130,131,],[7,16,28,36,39,56,71,96,121,136,137,]),'LBRACE':([7,16,34,39,45,47,48,49,50,51,52,54,56,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[9,22,45,57,45,45,45,45,45,45,45,45,81,45,45,45,45,45,45,45,45,45,45,45,45,-23,45,45,45,45,45,-22,45,45,45,45,45,]),'INHERITS':([7,],[10,]),'RBRACE':([9,11,12,13,19,22,23,29,40,42,43,44,53,69,71,72,73,74,82,83,88,89,90,91,92,93,94,97,99,100,107,109,113,119,127,128,133,140,143,],[-56,17,-6,-7,-9,-56,-8,35,-17,-18,-19,-20,-39,97,-25,-26,-27,-28,108,-24,-29,-30,-31,-32,-33,-34,-35,-21,-23,-36,122,-55,-22,-40,-38,-45,-49,-37,-54,]),'ID':([9,12,19,20,22,23,32,34,45,47,48,49,50,51,52,54,55,57,58,59,60,61,62,63,64,65,66,67,69,81,99,101,102,103,104,105,110,111,112,113,116,117,126,129,132,134,141,142,146,],[15,15,-9,24,15,-8,24,40,40,40,40,40,40,40,40,40,80,40,40,40,40,40,40,40,40,40,40,95,40,40,-23,40,40,118,40,120,40,40,125,-22,118,-47,40,-46,40,40,40,40,-48,]),'LPAREN':([15,34,40,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,95,99,101,102,104,110,111,113,125,126,132,134,141,142,],[20,50,59,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,50,111,-23,50,50,50,50,50,-22,134,50,50,50,50,50,]),'COLON':([15,24,26,31,80,118,120,],[21,30,33,37,106,130,131,]),'RPAREN':([20,25,27,36,38,40,42,43,44,53,59,71,72,73,74,75,83,84,85,86,87,88,89,90,91,92,93,94,97,100,109,111,119,123,124,127,128,133,134,139,140,143,],[26,31,-15,-16,-14,-17,-18,-19,-20,-39,-56,-25,-26,-27,-28,100,-24,109,-50,-51,-53,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-56,-40,-52,133,-38,-45,-49,-56,143,-37,-54,]),'COMMA':([25,27,36,38,40,42,43,44,53,71,72,73,74,79,83,85,87,88,89,90,91,92,93,94,97,100,109,119,121,123,127,128,133,137,138,140,143,145,],[32,-15,-16,-14,-17,-18,-19,-20,-39,-25,-26,-27,-28,105,-24,110,-53,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-41,-52,-38,-45,-49,-42,-43,-37,-54,-44,]),'ASSIGN':([28,40,121,137,],[34,58,132,142,]),'INTEGER':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,-23,42,42,42,42,42,-22,42,42,42,42,42,]),'BOOLEAN':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,-23,43,43,43,43,43,-22,43,43,43,43,43,]),'STRING':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,44,-23,44,44,44,44,44,-22,44,44,44,44,44,]),'NEW':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,46,-23,46,46,46,46,46,-22,46,46,46,46,46,]),'ISVOID':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,47,-23,47,47,47,47,47,-22,47,47,47,47,47,]),'INT_COMP':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,-23,48,48,48,48,48,-22,48,48,48,48,48,]),'NOT':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,49,-23,49,49,49,49,49,-22,49,49,49,49,49,]),'IF':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,-23,51,51,51,51,51,-22,51,51,51,51,51,]),'WHILE':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,52,-23,52,52,52,52,52,-22,52,52,52,52,52,]),'CASE':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,54,-23,54,54,54,54,54,-22,54,54,54,54,54,]),'LET':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,99,101,102,104,110,111,113,126,132,134,141,142,],[55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,55,-23,55,55,55,55,55,-22,55,55,55,55,55,]),'PLUS':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,60,-18,-19,-20,-39,60,-25,-26,-27,60,60,60,60,60,60,60,60,-29,-30,-31,-32,60,60,60,-21,60,-36,60,-55,60,60,60,60,-38,-45,-49,60,60,-37,-54,60,60,]),'MINUS':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,61,-18,-19,-20,-39,61,-25,-26,-27,61,61,61,61,61,61,61,61,-29,-30,-31,-32,61,61,61,-21,61,-36,61,-55,61,61,61,61,-38,-45,-49,61,61,-37,-54,61,61,]),'MULTIPLY':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,62,-18,-19,-20,-39,62,-25,-26,-27,62,62,62,62,62,62,62,62,62,62,-31,-32,62,62,62,-21,62,-36,62,-55,62,62,62,62,-38,-45,-49,62,62,-37,-54,62,62,]),'DIVIDE':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,63,-18,-19,-20,-39,63,-25,-26,-27,63,63,63,63,63,63,63,63,63,63,-31,-32,63,63,63,-21,63,-36,63,-55,63,63,63,63,-38,-45,-49,63,63,-37,-54,63,63,]),'LT':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,64,-18,-19,-20,-39,64,-25,-26,-27,64,64,64,64,64,64,64,64,-29,-30,-31,-32,None,None,None,-21,64,-36,64,-55,64,64,64,64,-38,-45,-49,64,64,-37,-54,64,64,]),'LTEQ':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,65,-18,-19,-20,-39,65,-25,-26,-27,65,65,65,65,65,65,65,65,-29,-30,-31,-32,None,None,None,-21,65,-36,65,-55,65,65,65,65,-38,-45,-49,65,65,-37,-54,65,65,]),'EQ':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,66,-18,-19,-20,-39,66,-25,-26,-27,66,66,66,66,66,66,66,66,-29,-30,-31,-32,None,None,None,-21,66,-36,66,-55,66,66,66,66,-38,-45,-49,66,66,-37,-54,66,66,]),'DOT':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,96,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,67,-18,-19,-20,-39,67,-25,67,67,67,67,67,67,67,67,67,67,67,67,67,67,67,67,67,112,-21,67,-36,67,-55,67,67,67,67,-38,-45,-49,67,67,-37,-54,67,67,]),'AT':([40,41,42,43,44,53,70,71,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,97,98,100,107,109,114,115,119,123,127,128,133,135,138,140,143,144,145,],[-17,68,-18,-19,-20,-39,68,-25,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,68,-21,68,-36,68,-55,68,68,68,68,-38,-45,-49,68,68,-37,-54,68,68,]),'THEN':([40,42,43,44,53,71,72,73,74,76,83,88,89,90,91,92,93,94,97,100,109,119,127,128,133,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,101,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-38,-45,-49,-37,-54,]),'LOOP':([40,42,43,44,53,71,72,73,74,77,83,88,89,90,91,92,93,94,97,100,109,119,127,128,133,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,102,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-38,-45,-49,-37,-54,]),'OF':([40,42,43,44,53,71,72,73,74,78,83,88,89,90,91,92,93,94,97,100,109,119,127,128,133,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,103,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-38,-45,-49,-37,-54,]),'ELSE':([40,42,43,44,53,71,72,73,74,83,88,89,90,91,92,93,94,97,100,109,114,119,127,128,133,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,126,-40,-38,-45,-49,-37,-54,]),'POOL':([40,42,43,44,53,71,72,73,74,83,88,89,90,91,92,93,94,97,100,109,115,119,127,128,133,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,127,-40,-38,-45,-49,-37,-54,]),'FI':([40,42,43,44,53,71,72,73,74,83,88,89,90,91,92,93,94,97,100,109,119,127,128,133,135,140,143,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-38,-45,-49,140,-37,-54,]),'IN':([40,42,43,44,53,71,72,73,74,79,83,88,89,90,91,92,93,94,97,100,109,119,121,127,128,133,137,138,140,143,145,],[-17,-18,-19,-20,-39,-25,-26,-27,-28,104,-24,-29,-30,-31,-32,-33,-34,-35,-21,-36,-55,-40,-41,-38,-45,-49,-42,-43,-37,-54,-44,]),'ESAC':([116,117,129,146,],[128,-47,-46,-48,]),'ARROW':([136,],[141,]),} + +_lr_action = {} +for _k, _v in _lr_action_items.items(): + for _x,_y in zip(_v[0],_v[1]): + if not _x in _lr_action: _lr_action[_x] = {} + _lr_action[_x][_k] = _y +del _lr_action_items + +_lr_goto_items = {'program':([0,],[1,]),'class_list':([0,],[2,]),'class':([0,2,],[3,5,]),'features_list_opt':([9,22,],[11,29,]),'features_list':([9,22,],[12,12,]),'empty':([9,22,59,111,134,],[13,13,86,86,86,]),'feature':([9,12,22,],[14,18,14,]),'formal_params_list':([20,],[25,]),'formal_param':([20,32,],[27,38,]),'expression':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,101,102,104,110,111,126,132,134,141,142,],[41,70,72,73,74,75,76,77,78,82,83,87,88,89,90,91,92,93,94,98,107,114,115,119,123,87,135,138,87,144,145,]),'let_expression':([34,45,47,48,49,50,51,52,54,57,58,59,60,61,62,63,64,65,66,69,81,101,102,104,110,111,126,132,134,141,142,],[53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,53,]),'block_list':([45,],[69,]),'nested_lets':([55,],[79,]),'arguments_list_opt':([59,111,134,],[84,124,139,]),'arguments_list':([59,111,134,],[85,85,85,]),'actions_list':([103,],[116,]),'action':([103,116,],[117,129,]),} + +_lr_goto = {} +for _k, _v in _lr_goto_items.items(): + for _x, _y in zip(_v[0], _v[1]): + if not _x in _lr_goto: _lr_goto[_x] = {} + _lr_goto[_x][_k] = _y +del _lr_goto_items +_lr_productions = [ + ("S' -> program","S'",1,None,None,None), + ('program -> class_list','program',1,'p_program','syntax_analyzer.py',29), + ('class_list -> class_list class SEMICOLON','class_list',3,'p_class_list','syntax_analyzer.py',35), + ('class_list -> class SEMICOLON','class_list',2,'p_class_list','syntax_analyzer.py',36), + ('class -> CLASS TYPE LBRACE features_list_opt RBRACE','class',5,'p_class','syntax_analyzer.py',42), + ('class -> CLASS TYPE INHERITS TYPE LBRACE features_list_opt RBRACE','class',7,'p_class_inherits','syntax_analyzer.py',53), + ('features_list_opt -> features_list','features_list_opt',1,'p_feature_list_opt','syntax_analyzer.py',65), + ('features_list_opt -> empty','features_list_opt',1,'p_feature_list_opt','syntax_analyzer.py',66), + ('features_list -> features_list feature SEMICOLON','features_list',3,'p_feature_list','syntax_analyzer.py',72), + ('features_list -> feature SEMICOLON','features_list',2,'p_feature_list','syntax_analyzer.py',73), + ('feature -> ID LPAREN formal_params_list RPAREN COLON TYPE LBRACE expression RBRACE','feature',9,'p_feature_method','syntax_analyzer.py',86), + ('feature -> ID LPAREN RPAREN COLON TYPE LBRACE expression RBRACE','feature',8,'p_feature_method_no_formals','syntax_analyzer.py',98), + ('feature -> ID COLON TYPE ASSIGN expression','feature',5,'p_feature_attr_initialized','syntax_analyzer.py',110), + ('feature -> ID COLON TYPE','feature',3,'p_feature_attr','syntax_analyzer.py',121), + ('formal_params_list -> formal_params_list COMMA formal_param','formal_params_list',3,'p_formal_list_many','syntax_analyzer.py',130), + ('formal_params_list -> formal_param','formal_params_list',1,'p_formal_list_many','syntax_analyzer.py',131), + ('formal_param -> ID COLON TYPE','formal_param',3,'p_formal','syntax_analyzer.py',137), + ('expression -> ID','expression',1,'p_expression_object_identifier','syntax_analyzer.py',145), + ('expression -> INTEGER','expression',1,'p_expression_integer_constant','syntax_analyzer.py',153), + ('expression -> BOOLEAN','expression',1,'p_expression_boolean_constant','syntax_analyzer.py',161), + ('expression -> STRING','expression',1,'p_expression_string_constant','syntax_analyzer.py',169), + ('expression -> LBRACE block_list RBRACE','expression',3,'p_expression_block','syntax_analyzer.py',184), + ('block_list -> block_list expression SEMICOLON','block_list',3,'p_block_list','syntax_analyzer.py',192), + ('block_list -> expression SEMICOLON','block_list',2,'p_block_list','syntax_analyzer.py',193), + ('expression -> ID ASSIGN expression','expression',3,'p_expression_assignment','syntax_analyzer.py',199), + ('expression -> NEW TYPE','expression',2,'p_expression_new','syntax_analyzer.py',213), + ('expression -> ISVOID expression','expression',2,'p_expression_isvoid','syntax_analyzer.py',222), + ('expression -> INT_COMP expression','expression',2,'p_expression_integer_complement','syntax_analyzer.py',230), + ('expression -> NOT expression','expression',2,'p_expression_boolean_complement','syntax_analyzer.py',239), + ('expression -> expression PLUS expression','expression',3,'p_expression_math_operations','syntax_analyzer.py',249), + ('expression -> expression MINUS expression','expression',3,'p_expression_math_operations','syntax_analyzer.py',250), + ('expression -> expression MULTIPLY expression','expression',3,'p_expression_math_operations','syntax_analyzer.py',251), + ('expression -> expression DIVIDE expression','expression',3,'p_expression_math_operations','syntax_analyzer.py',252), + ('expression -> expression LT expression','expression',3,'p_expression_math_comparisons','syntax_analyzer.py',273), + ('expression -> expression LTEQ expression','expression',3,'p_expression_math_comparisons','syntax_analyzer.py',274), + ('expression -> expression EQ expression','expression',3,'p_expression_math_comparisons','syntax_analyzer.py',275), + ('expression -> LPAREN expression RPAREN','expression',3,'p_expression_with_parenthesis','syntax_analyzer.py',292), + ('expression -> IF expression THEN expression ELSE expression FI','expression',7,'p_expression_if_conditional','syntax_analyzer.py',300), + ('expression -> WHILE expression LOOP expression POOL','expression',5,'p_expression_while_loop','syntax_analyzer.py',308), + ('expression -> let_expression','expression',1,'p_expression_let','syntax_analyzer.py',317), + ('let_expression -> LET nested_lets IN expression','let_expression',4,'p_expression_let_simple','syntax_analyzer.py',323), + ('nested_lets -> ID COLON TYPE','nested_lets',3,'p_nested_lets_simple','syntax_analyzer.py',331), + ('nested_lets -> nested_lets COMMA ID COLON TYPE','nested_lets',5,'p_nested_lets_simple','syntax_analyzer.py',332), + ('nested_lets -> ID COLON TYPE ASSIGN expression','nested_lets',5,'p_nested_lets_initialize','syntax_analyzer.py',348), + ('nested_lets -> nested_lets COMMA ID COLON TYPE ASSIGN expression','nested_lets',7,'p_nested_lets_initialize','syntax_analyzer.py',349), + ('expression -> CASE expression OF actions_list ESAC','expression',5,'p_expression_case','syntax_analyzer.py',371), + ('actions_list -> actions_list action','actions_list',2,'p_actions_list','syntax_analyzer.py',379), + ('actions_list -> action','actions_list',1,'p_actions_list','syntax_analyzer.py',380), + ('action -> ID COLON TYPE ARROW expression SEMICOLON','action',6,'p_action_expr','syntax_analyzer.py',386), + ('expression -> expression DOT ID LPAREN arguments_list_opt RPAREN','expression',6,'p_expression_dispatch','syntax_analyzer.py',399), + ('arguments_list_opt -> arguments_list','arguments_list_opt',1,'p_arguments_list_opt','syntax_analyzer.py',408), + ('arguments_list_opt -> empty','arguments_list_opt',1,'p_arguments_list_opt','syntax_analyzer.py',409), + ('arguments_list -> arguments_list COMMA expression','arguments_list',3,'p_arguments_list','syntax_analyzer.py',415), + ('arguments_list -> expression','arguments_list',1,'p_arguments_list','syntax_analyzer.py',416), + ('expression -> expression AT TYPE DOT ID LPAREN arguments_list_opt RPAREN','expression',8,'p_expression_static_dispatch','syntax_analyzer.py',422), + ('expression -> ID LPAREN arguments_list_opt RPAREN','expression',4,'p_expression_self_dispatch','syntax_analyzer.py',433), + ('empty -> ','empty',0,'p_empty','syntax_analyzer.py',446), +] diff --git a/src/compiler/components/parser/syntax_analyzer.py b/src/compiler/components/parser/syntax_analyzer.py new file mode 100644 index 00000000..7e2f50de --- /dev/null +++ b/src/compiler/components/parser/syntax_analyzer.py @@ -0,0 +1,474 @@ +import ply.yacc as yacc +from ply.yacc import YaccProduction, YaccSymbol +from compiler.utils.errors import error +from compiler.components.semantic.AST_definitions import * +from ..lexer.lexer_analyzer import lexer + +class pyCoolParser: + def __init__(self, tokens, source_program, real_col): + self.tokens = tokens + self.errors_parser = [] + self.source_program= source_program + self.real_col= real_col + self.parser = yacc.yacc(module=self) + + # precedence rules + precedence = ( + ('right', 'ASSIGN'), + ('right', 'NOT'), + ('nonassoc', 'LTEQ', 'LT', 'EQ'), + ('left', 'PLUS', 'MINUS'), + ('left', 'MULTIPLY', 'DIVIDE'), + ('right', 'ISVOID'), + ('right', 'INT_COMP'), + ('left', 'AT'), + ('left', 'DOT') + ) + def p_program(self, p): + """ + program : class_list + """ + p[0] = NodeProgram(p[1]) + + def p_class_list(self, p): + """ + class_list : class_list class SEMICOLON + | class SEMICOLON + """ + p[0] = (p[1],) if len(p) == 3 else p[1] + (p[2], ) + + def p_class(self, p): + """ + class : CLASS TYPE LBRACE features_list_opt RBRACE + """ + p[0] = NodeClass(idName = p[2], + methods= p[4]['methods'], + attributes= p[4]['attributes'], + parent = "Object" if p[2] != 'Object' else None, + line= p.slice[1].lineno, + column=(self.real_col[ str(p.slice[2]) ] ) ) + + def p_class_inherits(self, p): + """ + class : CLASS TYPE INHERITS TYPE LBRACE features_list_opt RBRACE + """ + p[0] = NodeClass(idName = p[2], + methods= p[6]['methods'], + attributes= p[6]['attributes'], + parent = p[4], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[2]) ], + parent_col= self.real_col[str(p.slice[4] )]) + + def p_feature_list_opt(self, p): + """ + features_list_opt : features_list + | empty + """ + p[0] = p[1] if p[1] else { 'methods': [], 'attributes': [] } + + def p_feature_list(self, p): + """ + features_list : features_list feature SEMICOLON + | feature SEMICOLON + """ + if len(p) == 3: + p[0] = { 'methods': [], 'attributes': [] } + key = 'methods' if type(p[1]) is NodeClassMethod else 'attributes' + p[0][key] += [p[1]] + else: + key = 'methods' if type(p[2]) is NodeClassMethod else 'attributes' + p[1][key] += [p[2]] + p[0] = p[1] + + def p_feature_method(self, p): + """ + feature : ID LPAREN formal_params_list RPAREN COLON TYPE LBRACE expression RBRACE + """ + p[0] = NodeClassMethod(idName=p[1], + formal_param_list= p[3], + returnType=p[6], + body=p[8], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ], + columnType= self.real_col[ str(p.slice[6]) ]) + + def p_feature_method_no_formals(self, p): + """ + feature : ID LPAREN RPAREN COLON TYPE LBRACE expression RBRACE + """ + p[0] = NodeClassMethod(idName=p[1], + formal_param_list= [], + returnType=p[5], + body=p[7], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ], + columnType= self.real_col[ str(p.slice[5]) ]) + + def p_feature_attr_initialized(self, p): + """ + feature : ID COLON TYPE ASSIGN expression + """ + p[0] = NodeAttr(idName= p[1], + _type= p[3], + expr= p[5], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ], + columnTypeAttr= self.real_col[ str(p.slice[3]) ]) + + def p_feature_attr(self, p): + """ + feature : ID COLON TYPE + """ + p[0] = NodeAttr(idName= p[1], _type= p[3], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ], + columnTypeAttr= self.real_col[ str(p.slice[3]) ]) + + def p_formal_list_many(self, p): + """ + formal_params_list : formal_params_list COMMA formal_param + | formal_param + """ + p[0] = (p[1], ) if len(p) == 2 else p[1] + (p[3], ) + + def p_formal(self, p): + """ + formal_param : ID COLON TYPE + """ + p[0] = NodeFormalParam(idName=p[1], param_type=p[3], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_object_identifier(self, p): + """ + expression : ID + """ + p[0]= NodeObject(idName= p[1] , + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_integer_constant(self, p): + """ + expression : INTEGER + """ + p[0]= NodeInteger(content= p[1], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_boolean_constant(self, p): + """ + expression : BOOLEAN + """ + p[0]= NodeBoolean(content= p[1], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_string_constant(self, p): + """ + expression : STRING + """ + p[0]= NodeString(content= p[1], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ] - len(p[1]) - 1) + + #def p_expr_self(self, p): + # """ + # expression : SELF + # """ + # p[0]= NodeSelf(line= p.slice[1].lineno, + # column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_block(self, p): + """ + expression : LBRACE block_list RBRACE + """ + p[0]= NodeBlock(expr_list= p[2], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_block_list(self, p): + """ + block_list : block_list expression SEMICOLON + | expression SEMICOLON + """ + p[0]= (p[1], ) if len(p) == 3 else p[1] + (p[2], ) + + def p_expression_assignment(self, p): + """ + expression : ID ASSIGN expression + """ + p[0] = NodeAssignment(nodeObject= NodeObject(idName= p[1], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]), + expr= p[3], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ], + columnAssign= self.real_col[ str(p.slice[2]) ]) + +# ######################### UNARY OPERATIONS ####################################### + + def p_expression_new(self, p): + """ + expression : NEW TYPE + """ + p[0] = NodeNewObject(new_type= p[2], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + + def p_expression_isvoid(self, p): + """ + expression : ISVOID expression + """ + p[0] = NodeIsVoid(expr= p[2], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_integer_complement(self, p): + """ + expression : INT_COMP expression + """ + p[0] = NodeIntegerComplement(p[2], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + + def p_expression_boolean_complement(self, p): + """ + expression : NOT expression + """ + p[0] = NodeBooleanComplement(p[2], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + # ######################### PARENTHESIZED, MATH & COMPARISONS ##################### + + def p_expression_math_operations(self, p): + """ + expression : expression PLUS expression + | expression MINUS expression + | expression MULTIPLY expression + | expression DIVIDE expression + """ + if p[2] == '+': + p[0] = NodeAddition(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + elif p[2] == '-': + p[0] = NodeSubtraction(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + elif p[2] == '*': + p[0] = NodeMultiplication(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + elif p[2] == '/': + p[0] = NodeDivision(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + + def p_expression_math_comparisons(self, p): + """ + expression : expression LT expression + | expression LTEQ expression + | expression EQ expression + """ + if p[2] == '<': + p[0] = NodeLessThan(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + elif p[2] == '<=': + p[0] = NodeLessThanOrEqual(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + elif p[2] == '=': + p[0] = NodeEqual(first=p[1], second=p[3], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + + def p_expression_with_parenthesis(self, p): + """ + expression : LPAREN expression RPAREN + """ + p[0] = p[2] + + # ######################### CONTROL FLOW EXPRESSIONS ############################## + + def p_expression_if_conditional(self, p): + """ + expression : IF expression THEN expression ELSE expression FI + """ + p[0]= NodeIf(predicate=p[2], then_body=p[4], else_body=p[6], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_expression_while_loop(self, p): + """ + expression : WHILE expression LOOP expression POOL + """ + p[0] = NodeWhileLoop(predicate=p[2], body=p[4], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + ## ######################### LET EXPRESSIONS ######################################## + def p_expression_let(self, p): + """ + expression : let_expression + """ + p[0]= p[1] + + def p_expression_let_simple(self, p): + """ + let_expression : LET nested_lets IN expression + """ + p[0]= NodeLetComplex(nested_lets= p[2], body= p[4], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_nested_lets_simple(self, p): + """ + nested_lets : ID COLON TYPE + | nested_lets COMMA ID COLON TYPE + """ + if p[2] == ":": + p[0]= [NodeLet(idName= p[1], returnType= p[3], body = None, + line= p.slice[1].lineno, + column= self.real_col[ str(p.slice[1]) ])] + else: + p[1].append(NodeLet(idName= p[3], + returnType= p[5], + body= None, + line= p.slice[2].lineno, + column= self.real_col[str(p.slice[2])])) + p[0]= p[1] + + def p_nested_lets_initialize(self, p): + """ + nested_lets : ID COLON TYPE ASSIGN expression + | nested_lets COMMA ID COLON TYPE ASSIGN expression + """ + if p[2] == ":": + p[0] = [NodeLet(idName= p[1], + returnType= p[3], + body = p[5], + line = p.slice[1].lineno, + column= self.real_col[ str(p.slice[1]) ] )] + else: + p[1].append( + NodeLet(idName= p[3], + returnType= p[5], + body= p[7], + line= p.slice[2].lineno, + column= self.real_col[ str(p.slice[2]) ]) + ) + p[0]= p[1] + + # ######################### CASE EXPRESSION ######################################## + + def p_expression_case(self, p): + """ + expression : CASE expression OF actions_list ESAC + """ + p[0]= NodeCase(expr=p[2], actions=p[4], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + def p_actions_list(self, p): + """ + actions_list : actions_list action + | action + """ + p[0]= (p[1],) if len(p) == 2 else p[1] + (p[2],) + + def p_action_expr(self, p): + """ + action : ID COLON TYPE ARROW expression SEMICOLON + """ + p[0] = NodeCaseAction(idName= p[1], + _type= p[3], + expr= p[5], + line= p.slice[1].lineno, + column= self.real_col[ str(p.slice[1]) ], + typeColumn= self.real_col[ str(p.slice[3]) ]) + + # ######################### METHODS DISPATCH ###################################### + + def p_expression_dispatch(self, p): + """ + expression : expression DOT ID LPAREN arguments_list_opt RPAREN + """ + p[0] = NodeDynamicDispatch(expr=p[1], + method=p[3], arguments=p[5], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ]) + + def p_arguments_list_opt(self, p): + """ + arguments_list_opt : arguments_list + | empty + """ + p[0] = tuple() if p.slice[1].type == "empty" else p[1] + + def p_arguments_list(self, p): + """ + arguments_list : arguments_list COMMA expression + | expression + """ + p[0]= (p[1], ) if len(p) == 2 else p[1] + (p[3], ) + + def p_expression_static_dispatch(self, p): + """ + expression : expression AT TYPE DOT ID LPAREN arguments_list_opt RPAREN + """ + p[0] = NodeStaticDispatch(expr=p[1], + dispatch_type=p[3], method=p[5], arguments=p[7], + line= p.slice[2].lineno, + column=self.real_col[ str(p.slice[2]) ], + columnType = self.real_col[str(p.slice[3])], + columnIdMethod= self.real_col[str(p.slice[5])]) + + def p_expression_self_dispatch(self, p): + """ + expression : ID LPAREN arguments_list_opt RPAREN + """ + p[0] = NodeDynamicDispatch(expr=NodeSelf(line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]), + method=p[1], arguments=p[3], + line= p.slice[1].lineno, + column=self.real_col[ str(p.slice[1]) ]) + + + # ######################### ################## ################################### + + def p_empty(self, p): + """ + empty : + """ + p[0]= None + + + def p_error(self, p): + """ + Error rule for Syntax Errors handling and reporting. + """ + if p: + + self.errors_parser.append( + error(message= "Error at or near %s" %p.value, + error_type="SyntacticError", + row_and_col= (p.lineno, self.real_col[ str(p) ] ))) + + else: + self.errors_parser.append( + error(message= "EOF in string", + error_type="SyntacticError", + row_and_col= (0, 0 ))) + + +def run_parser(tokens, source_program, real_col): + #print("The source_program ", source_program) + parserCool = pyCoolParser(tokens, source_program, real_col) + lexer.lineno = 1 + ast_result = parserCool.parser.parse(source_program, lexer=lexer) + return ast_result, parserCool.errors_parser diff --git a/src/compiler/components/semantic/AST_definitions.py b/src/compiler/components/semantic/AST_definitions.py new file mode 100644 index 00000000..bbed88e4 --- /dev/null +++ b/src/compiler/components/semantic/AST_definitions.py @@ -0,0 +1,613 @@ +from json import dumps +class Node: + def __init__(self, line = 0, column = 0): + self.line = line + self.column = column + + @property + def clsname(self): + return str(self.__class__.__name__) + + def to_tuple(self): + return tuple([ + ("node_class_name", self.clsname) + ]) + + def to_readable(self): + return "{}".format(self.clsname) + + def __repr__(self): + return self.toJSON() + + def __str__(self): + return str(self.to_readable()) + + def __getitem__(self, x): + return self.__dict__[x] + + def __setitem__(self, x, y): + self.__dict__[x]= y + + def __iter__(self): + return self.__dict__.__iter__() + + def __eq__(self, other): + return type(self) == type(other) and self.idName == other.idName + + def toJSON(self): + return dumps(self, default=lambda o: o.__dict__, + sort_keys=True, indent=4, separators=(',', ': ')) + + +class NodeProgram(Node): + def __init__(self, class_list): + super().__init__() + self.class_list = class_list + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("classes", self.class_list) + ]) + + def to_readable(self): + return "{}(classes={})".format(self.clsname, self.class_list) + +class NodeClassTuple(Node, tuple): + def __init__(self, classes): + self.classes = classes + +class NodeClass(Node): + def __init__(self, idName: str, methods, attributes, parent, + line = 0, column = 0, parent_col = -1): + super().__init__(line= line, column= column) + self.idName = idName + self.methods = methods + self.attributes = attributes + self.parent = parent + self.parent_col = parent_col + + + + def to_readable(self): + return "{}(name='{}', parent={}, methods={}, attributes={})".format( + self.clsname, self.idName, self.parent, + self.methods, self.attributes) + +class NodeFeature(Node): + def __init__(self, line, column): + super(NodeFeature, self).__init__(line= line, column= column) + +#No se si poner aqui una clase para heredar , que sea feature_class. +#Tengo que ver si a futuro necesito iterar por los elementos de una clase +#de manera abstracta. +class NodeClassMethod(NodeFeature): + def __init__(self, + idName: str, + formal_param_list, + returnType: str, + body, + line, + column, + columnType): + super().__init__(line= line, column= column) + self.idName = idName + self.formal_param_list= formal_param_list + self.returnType = returnType + self.body = body + self.columnType= columnType + + def to_readable(self): + return "{}(name='{}', formal_param_list={}, returnType={}, body={})".format( + self.clsname, self.idName, self.formal_param_list, + self.returnType, self.body + ) + +class NodeAttr(NodeFeature): + def __init__(self, idName, _type, + line, column, expr= None, columnTypeAttr= None): + super().__init__(line= line, column= column) + self.idName= idName + self._type= _type + self.expr= expr + self.columnTypeAttr= columnTypeAttr + +class NodeFormalParam(NodeFeature): + def __init__(self, idName, param_type, line, column): + super().__init__(line= line, column= column) + self.idName = idName + self._type = param_type + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("name", self.idNme), + ("param_type", self._type) + ]) + + def to_readable(self): + return "{}(name='{}', param_type={})".format(self.clsname, + self.idName, self._type) + +class NodeObject(Node): + def __init__(self, idName, line, column): + super().__init__(line= line, column= column) + self.idName = idName + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("name", self.idName) + ]) + + def to_readable(self): + return "{}(name='{}')".format(self.clsname, self.idName) + +class NodeSelf(NodeObject): + def __init__(self, line, column): + super().__init__(idName= "SELF", line= line, column= column) + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname) + ]) + + def to_readable(self): + return "{}".format(self.clsname) + + +class NodeConstant(Node): + def __init__(self, line, column): + super().__init__(line= line, column= column) + + +class NodeInteger(NodeConstant): + def __init__(self, content, line, column): + super().__init__(line= line, column= column) + self.content = content + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("content", self.content) + ]) + + def to_readable(self): + return "{}(content={})".format(self.clsname, self.content) + + +class NodeBoolean(NodeConstant): + def __init__(self, content, line, column): + super().__init__(line= line, column= column) + self.content = content + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("content", self.content) + ]) + + def to_readable(self): + return "{}(content={})".format(self.clsname, self.content) + +class NodeString(NodeConstant): + def __init__(self, content, line, column): + super().__init__(line= line, column= column) + self.content = content + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("content", self.content) + ]) + + def to_readable(self): + return "{}(content={})".format(self.clsname, repr(self.content)) + +# Cada expresión debe tener una función de evaluación asociada. +# Con un valor de retorno x. +class NodeExpr(Node): + def __init__(self, line, column): + super().__init__(line= line, column= column) + + +class NodeNewObject(NodeExpr): + def __init__(self, new_type, line, column): + super().__init__(line= line, column= column) + self.type = new_type + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("type", self.type) + ]) + + def to_readable(self): + return "{}(type={})".format(self.clsname, self.type) + + +class NodeIsVoid(NodeExpr): + def __init__(self, expr, line, column): + super().__init__(line= line, column= column) + self.expr= expr + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("expr", self.expr) + ]) + + def to_readable(self): + return "{}(expr={})".format(self.clsname, self.expr) + + +class NodeAssignment(NodeExpr): + def __init__(self, nodeObject, expr, line, column, columnAssign): + super().__init__(line= line, column= column) + self.nodeObject = nodeObject + self.expr = expr + self.columnAssign= columnAssign + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("nodeObject", self.nodeObject), + ("expr", self.expr) + ]) + + def to_readable(self): + return "{}(nodeObject={}, expr={})".format(self.clsname, + self.nodeObject, self.expr) + + +class NodeBlock(NodeExpr): + def __init__(self, expr_list, line, column): + super().__init__(line = line, column = column) + self.expr_list = expr_list + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("expr_list", self.expr_list) + ]) + + def to_readable(self): + return "{}(expr_list={})".format(self.clsname, self.expr_list) + + +class NodeDynamicDispatch(NodeExpr): + def __init__(self, expr, method, arguments, line, column): + super().__init__(line= line, column= column) + self.expr = expr + self.method = method + self.arguments = arguments if arguments is not None else tuple() + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("expr", self.expr), + ("method", self.method), + ("arguments", self.arguments) + ]) + + def to_readable(self): + return "{}(expr={}, method={}, arguments={})".format( + self.clsname, self.expr, self.method, self.arguments) + + +class NodeStaticDispatch(NodeExpr): + def __init__(self, + expr, + dispatch_type, + method, + arguments, + line, + column, + columnType, + columnIdMethod): + super().__init__(line= line, column= column) + self.expr = expr + self.dispatch_type = dispatch_type + self.method = method + self.arguments = arguments if arguments is not None else tuple() + self.columnType= columnType + self.columnIdMethod= columnIdMethod + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("expr", self.expr), + ("dispatch_type", self.dispatch_type), + ("method", self.method), + ("arguments", self.arguments) + ]) + + def to_readable(self): + return "{}(expr={}, dispatch_type={}, method={}, arguments={})".format( + self.clsname, self.expr, self.dispatch_type, + self.method, self.arguments) + + +class NodeLetComplex(NodeExpr): + def __init__(self, nested_lets, body, line, column): + super().__init__(line= line, column= column) + self.nestedLets= nested_lets if type(nested_lets) is list else [nested_lets] + self.body= body + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("nested_lets", self.nestedLets), + ("body", self.body) + ]) + + def to_readable(self): + return "{}(nested_lets={}, body={})".format( + self.clsname, self.nestedLets, self.body) + + +class NodeLet(NodeExpr): + def __init__(self, idName, returnType, body, line, column): + super().__init__(line= line, column= column) + self.idName= idName + self.type= returnType + self.body= body + + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("idName", self.idName), + ("returnType", self.type), + ("body", self.body) + ]) + + def to_readable(self): + return "{}(idName={}, returnType={}, body={})".format( + self.clsname, self.idName, self.type, + self.body) + + +class NodeIf(NodeExpr): + def __init__(self, predicate, then_body, else_body, line, column): + super().__init__(line= line, column= column) + self.predicate = predicate + self.then_body = then_body + self.else_body = else_body + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("predicate", self.predicate), + ("then_body", self.then_body), + ("else_body", self.else_body) + ]) + + def to_readable(self): + return "{}(predicate={}, then_body={}, else_body={})".format( + self.clsname, self.predicate, self.then_body, self.else_body) + + +class NodeWhileLoop(NodeExpr): + def __init__(self, predicate, body, line, column): + super().__init__(line= line, column= column) + self.predicate = predicate + self.body = body + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("predicate", self.predicate), + ("body", self.body) + ]) + + def to_readable(self): + return "{}(predicate={}, body={})".format(self.clsname, + self.predicate, self.body) + + +class NodeCase(NodeExpr): + def __init__(self, expr, actions, line, column): + super().__init__(line= line, column= column) + self.expr = expr + self.actions = actions + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("expr", self.expr), + ("actions", self.actions) + ]) + + def to_readable(self): + return "{}(expr={}, actions={})".format(self.clsname, + self.expr, self.actions) + + +class NodeCaseAction(NodeExpr): + def __init__(self, idName, expr, _type, line, column, typeColumn): + super().__init__(line= line, column= column) + self.idName= idName + self.expr= expr + self.type= _type + self.typeColumn= typeColumn + +# ############################## UNARY OPERATIONS ################################## + + +class NodeUnaryOperation(NodeExpr): + def __init__(self, line, column): + super().__init__(line= line, column= column) + +class NodeIntegerComplement(NodeUnaryOperation): + def __init__(self, integer_expr, line, column): + super().__init__(line= line, column= column) + self.symbol = "~" + self.integer_expr = integer_expr + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("integer_expr", self.integer_expr) + ]) + + def to_readable(self): + return "{}(expr={})".format(self.clsname, self.integer_expr) + + +class NodeBooleanComplement(NodeUnaryOperation): + def __init__(self, boolean_expr, line, column): + super().__init__(line= line, column= column) + self.symbol = "!" + self.boolean_expr = boolean_expr + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("boolean_expr", self.boolean_expr) + ]) + + def to_readable(self): + return "{}(expr={})".format(self.clsname, self.boolean_expr) + +# ############################## BINARY OPERATIONS ################################## + +class NodeBinaryOperation(NodeExpr): + def __init__(self, line, column): + super().__init__(line= line, column= column) + self.type= '' + +class NodeAddition(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "+" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeSubtraction(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "-" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeMultiplication(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "*" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeDivision(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "/" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeEqual(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "=" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeLessThan(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "<" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + +class NodeLessThanOrEqual(NodeBinaryOperation): + def __init__(self, first, second, line, column): + super().__init__(line= line, column= column) + self.symbol = "<=" + self.first = first + self.second = second + + def to_tuple(self): + return tuple([ + ("class_name", self.clsname), + ("first", self.first), + ("second", self.second) + ]) + + def to_readable(self): + return "{}(first={}, second={})".format(self.clsname, + self.first, self.second) + + + diff --git a/src/compiler/components/semantic/__init__.py b/src/compiler/components/semantic/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/components/semantic/context.py b/src/compiler/components/semantic/context.py new file mode 100644 index 00000000..d822e0ee --- /dev/null +++ b/src/compiler/components/semantic/context.py @@ -0,0 +1,449 @@ +from .AST_definitions import * +from compiler.utils.errors import error, interceptError +import json +import sys + +class jsonable: + def toJSON(self): + return dumps(self, default=lambda o: o.__dict__, + sort_keys=True, indent=4, separators=(',', ': ')) + + def __repr__(self): + return self.toJSON() +class Type(jsonable): + def __init__(self, idName, attributes, + methods, builtIn= False, parent=None): + + self.idName= idName + self.parent= parent + self.attributes= attributes + self.methods= methods + self.builtIn= builtIn + self.inheritsAttr= {} + self.inheritsMethods= {} + self.children= [] + +class feature(jsonable): + def __init__(self, idName, wrapperType): + self.wrapperType = wrapperType + self.idName= idName + + def __eq__(self, other): + if type(self) == type(other): + for f in self.__dict__: + if not self.__dict__[f] == other.__dict__[f]: + return False + return True + return False + +class Attribute(feature): + def __init__(self, idName: str, _type: str, wrapperType): + super().__init__(idName= idName, wrapperType= wrapperType) + self._type = _type + + +class Method(feature): + def __init__(self, idName: str, + returnType: str, + argNames, + argTypes, + wrapperType): + super().__init__(idName= idName, wrapperType= wrapperType) + self.returnType = returnType + self.argNames = argNames + self.argTypes= argTypes + + +class globalContext: + def __init__(self, dictionaries ={}): + self.types= { } + self.basics = ['Object', 'IO', 'String', 'Bool', 'Int'] + + def createType(self, node: NodeClass): + return interceptError( + validationFunc= lambda: not node.idName in self.types, + errorOption= 'repeated class' if not node.idName in self.basics else 'repeated class basic', + idName= node.idName, + row_and_col = (node.line, node.column) + )or self.types.update({ + node.idName: + Type (idName= node.idName, + attributes= {}, + methods= {}, + parent= node.parent, + builtIn= node.idName in ['String', 'Bool', 'Int']) + }) + + def actualizeChildren(self): + for _type, info in self.types.items(): + if _type != 'Object': + self.types[info.parent].children.append(_type) + + def checkGoodInheritance(self, node: NodeClass): + if node.idName == 'Object': return + parent = 'Object' if not node.parent else node.parent + return interceptError( + validationFunc= lambda: node.idName in self.types, + errorOption= 'undefined type', + idName= node.idName, + row_and_col= (node.line, node.column) + ) or interceptError ( + validationFunc= lambda: node.parent in + self.types, + errorOption= 'undefined type', + idName= node.parent, + row_and_col= (node.line, node.parent_col) + ) or interceptError( + validationFunc= lambda: not self.types[node.parent].builtIn, + errorOption= 'built-in inheritance', + idName= node.idName, + idParent= node.parent, + row_and_col= (node.line, node.parent_col) + ) or interceptError( + validationFunc= lambda: not self.isSubtype ( + superType= node.idName, subType= node.parent), + errorOption= 'inheritance from child', + idChild= node.idName, + row_and_col= (node.line, node.parent_col) + ) + + + def checkGoodOverwriteMethod(self, node: NodeClassMethod, idType): + idParent= self.types[idType].parent + childInfoMethod= self.types[idType].methods.get(node.idName) + + parentInfoMethod= self.types[idParent].methods.get(node.idName, None) or self.types[idParent].inheritsMethods.get(node.idName, None) + if parentInfoMethod: + badIndexParam = next((i for i in range (len( childInfoMethod.argTypes)) + if childInfoMethod.argTypes[i] != parentInfoMethod.argTypes[i]), False) if len(node.formal_param_list) == len(parentInfoMethod.argTypes) else None + return interceptError( + validationFunc= lambda: len(node.formal_param_list) == len(parentInfoMethod.argTypes) , + errorOption= 'bad length in redefine', + methodName= node.idName, + row_and_col= (node.line, node.column) + ) or interceptError ( + validationFunc= lambda: not badIndexParam, + errorOption= 'bad redefine method', + methodName= node.idName, + badType= node.formal_param_list[badIndexParam]._type if badIndexParam else None, + goodType= parentInfoMethod.argTypes[badIndexParam] if badIndexParam else None, + row_and_col= (node.formal_param_list[badIndexParam].line if badIndexParam else None, + node.formal_param_list[badIndexParam].column if badIndexParam else None) + ) or interceptError ( + validationFunc = lambda: node.returnType == parentInfoMethod.returnType, + errorOption= 'bad returnType in redefine method', + methodName= node.idName, + badType= node.returnType, + goodType= parentInfoMethod.returnType, + row_and_col= (node.line, node.columnType) + ) + + def checkNotOverwriteAttr(self, node: NodeAttr, idType): + idParent= self.types[idType].parent + return interceptError( + validationFunc= lambda : not (self.types[idParent].attributes.get(node.idName, None) or self.types[idParent].inheritsAttr.get(node.idName, None)), + errorOption= 'bad redefine attr', + badAttr= node.idName, + row_and_col= (node.line, node.column) + ) + + def actualizeInherits(self, node: NodeClass): + idParent= self.types[node.idName].parent + self.actualizeFeatures(dictChild= self.types[node.idName].attributes, + dictToActualize= self.types[node.idName].inheritsAttr, + dictParent= self.types[idParent].inheritsAttr) + self.actualizeFeatures(dictChild= self.types[node.idName].attributes, + dictToActualize= self.types[node.idName].inheritsAttr, + dictParent= self.types[idParent].attributes) + self.actualizeFeatures(dictChild= self.types[node.idName].methods, + dictToActualize= self.types[node.idName].inheritsMethods, + dictParent= self.types[idParent].inheritsMethods) + self.actualizeFeatures(dictChild= self.types[node.idName].methods, + dictToActualize= self.types[node.idName].inheritsMethods, + dictParent= self.types[idParent].methods) + + + def actualizeFeatures(self, dictChild, dictToActualize, dictParent ): + dictToActualize.update({ + f.idName: f for f in dictParent.values() if not f.idName in dictChild + }) + + + def getType(self, idName: str, row_and_col): + return interceptError( + validationFunc= lambda: idName in self.types, + errorOption= 'undefined type', + idName= idName, + row_and_col= row_and_col + ) or self.types.get(idName) + + def defineAttrInType(self, typeName: str, attr: NodeAttr): + + return interceptError( + validationFunc= lambda : not attr.idName in + self.types[typeName].attributes, + errorOption= 'repeated attr', + idName= attr.idName, + row_and_col= (attr.line, attr.column) + ) or interceptError( + validationFunc= lambda: ('__prim_zero_slot' == attr._type or '__prim_empty_slot'== attr._type) or attr._type in self.types, + errorOption= 'undefined type in attr', + idAttr= attr.idName, + idBadType= attr._type, + row_and_col= (attr.line, attr.columnTypeAttr ) + ) or self.types[typeName].attributes.update({ + attr.idName: Attribute(idName= attr.idName, + _type= attr._type, + wrapperType= typeName) + }) + + def defineMethod(self, typeName: str, + node: NodeClassMethod): + appears = {} + for f in node.formal_param_list: + info = appears.get(f.idName, None) + if not info: + appears.update({f.idName: f}) + else: + return error( + error_type='SemanticError', + row_and_col= (f.line, f.column), + message= 'Formal parameter %s is multiply defined.' %f.idName + ) + + return interceptError( + validationFunc= lambda: not node.idName in + self.types[typeName].methods, + errorOption= 'repeated method', + idName= node.idName, + row_and_col= (node.line, node.column) + ) or self.types[typeName].methods.update({ + node.idName: Method(idName= node.idName, + returnType= node.returnType, + argNames= [f.idName for f in node.formal_param_list] , + argTypes= [f._type for f in node.formal_param_list], + wrapperType= typeName) + }) + + def checkDynamicDispatch(self, + typeName, method, arguments, row_and_col): + + methodInfo = self.types[typeName].methods.get(method, None) + if not methodInfo: + methodInfo= self.types[typeName].inheritsMethods.get(method, None) + notAncestorArgs= [arguments[i] for i in range (len(arguments)) + if arguments[i] != methodInfo.argTypes[i] + and not self.isAncestor(arguments[i], + methodInfo.argTypes[i])] + + return interceptError( + validationFunc= lambda : not methodInfo is None, + errorOption= 'undefined method in class', + idName= method, + className= typeName, + row_and_col= row_and_col + ) or interceptError ( + validationFunc= lambda : notAncestorArgs == [], + errorOption= 'argument types in dispatch are not subtypes', + idName= method, + badArgs= notAncestorArgs, + row_and_col= row_and_col + ) or methodInfo.returnType + + + + def __repr__(self): + return self.__str__() + + def __str__(self): + return json.dumps(self.types, indent = 4, cls= MyEncoder) + + def buildEnv (self, typeName): + typeInfo= self.types[typeName] + d = {typeInfo.attributes[attr].idName: + typeInfo.attributes[attr]._type + for attr in typeInfo.attributes } + d.update({ typeInfo.inheritsAttr[attr].idName: + typeInfo.inheritsAttr[attr]._type + for attr in typeInfo.inheritsAttr } ) + d.update({'wrapperType': typeName}) + return d + + def buildEnvForMethod(self, node: NodeClassMethod, previousEnv): + newEnv = previousEnv.copy() + newEnv.update({ f.idName: f._type + for f in node.formal_param_list }) + badFormalParam = next((f for f in node.formal_param_list + if f.idName == 'self'), None) + return interceptError( + validationFunc= lambda : not badFormalParam, + errorOption='self parameter', + row_and_col= (badFormalParam.line, badFormalParam.column) if badFormalParam else (0,0) + )or newEnv + + def isSubtype(self, subType, superType): + while subType: + if subType == superType: + return True + subType = self.types[subType].parent + return False + + def checkAssign(self, nameObject, + nodeType, returnType, + row_and_col, errorOption, columnAssign = 0): + + return interceptError ( + validationFunc= lambda: nameObject != 'self', + errorOption='self assign', + row_and_col= (row_and_col[0], columnAssign) + ) or interceptError ( + validationFunc= lambda : nodeType in self.types, + errorOption= 'undefined type', + idName= nodeType, + row_and_col= row_and_col + ) or interceptError( + validationFunc= lambda : self.isSubtype(subType= returnType, + superType= nodeType), + errorOption= errorOption, + idName= nameObject, + type1= returnType, + type2= nodeType, + row_and_col= row_and_col + ) + + def checkDispatchTypes(self, typeLeftMost, typeRight, returnType, row_and_col): + return interceptError(validationFunc= lambda: self.isSubtype(subType= typeLeftMost, + superType= typeRight), + errorOption= 'bad static dispatch', + typeLef = typeLeftMost, + typeRight= typeRight, + row_and_col= row_and_col) or returnType + + + def checkMethodInType (self, idType, idMethod, row_and_col): + return interceptError(validationFunc= lambda: idMethod in self.types[idType].methods or idMethod in self.types[idType].inheritsMethods, + errorOption= 'not method in class', + idMethod= idMethod, + row_and_col= row_and_col) or self.types[idType].methods.get(idMethod, None) or self.types[idType].inheritsMethods.get(idMethod, None) + + + def checkReturnType(self, nodeType , returnType, row_and_col, errorOption): + return interceptError( + validationFunc= lambda : self.isSubtype(subType= returnType, + superType= nodeType), + errorOption= errorOption, + type1= nodeType, + type2= returnType, + row_and_col= row_and_col + ) or returnType + + def checkBoolInPredicate(self, node: NodeWhileLoop, resultExpr): + return interceptError( + validationFunc= lambda : resultExpr == 'Bool', + errorOption= 'bad predicate', + row_and_col= (node.line, node.predicate.column) + ) or 'Bool' + + def checkNonRepetition(self, nodeActions): + repetitionList = [] + for action in nodeActions: + if not action.type in repetitionList: + repetitionList.append(action.type) + else: + return error(error_type= 'SemanticError', + row_and_col= (action.line, action.typeColumn), + message = 'Duplicate branch %s in case statement.' %action.type) + + + def searchValue(self, node: NodeObject, row_and_col, environment): + return interceptError( + validationFunc= lambda: node.idName + in environment, + errorOption='undefined symbol', + row_and_col= row_and_col, + symbolName= node.idName) or environment[node.idName] + + def checkArithmetic(self, type1, type2, row_and_col, symbolOp, arithmeticOp): + return interceptError(validationFunc= lambda: type1 == type2, + errorOption= 'arithmetic fail', + type1= type1, + type2= type2, + symbolOp= symbolOp, + row_and_col= row_and_col) or ('Int' * arithmeticOp) or 'Bool' + + def checkEqualOp(self, type1, type2, row_and_col): + return interceptError(validationFunc= lambda: not (type1 or type2) + in {'Int', 'Bool', 'String'} or type1 == type2, + errorOption= 'comparison fail', + row_and_col = row_and_col) or self.types['Bool'].idName + + def checkArgumentsInDispatch(self, + node, + argNames, + typeExprOfArgs, + argTypes): + if len(typeExprOfArgs) != len(argTypes): + return error(error_type= 'SemanticError', + row_and_col= (node.line, node.column + 1), # I don't like this +1. It looks like a patch. + message= "Method %s called with wrong number of arguments." %(node.method)) + + badIndex = next((i for i in range(len( typeExprOfArgs)) + if not self.isSubtype(subType=typeExprOfArgs[i], + superType= argTypes[i])), None) + (badArg, badType, realType, row_and_col)= (argNames[badIndex], + typeExprOfArgs[badIndex], + argTypes[badIndex], + (node.arguments[badIndex].expr.line, node.arguments[badIndex].expr.column)) if badIndex else (None, None, None, None) + + return interceptError(validationFunc= lambda: not badIndex, + errorOption= 'bad dispatch', + idMethod= node.method, + badArg= badArg, + badType= badType, + realType= realType, + row_and_col= row_and_col) + + + + def LCA(self, idName1, idName2): + path1 = self.pathToObject( idName1) + path2 = self.pathToObject( idName2) + possibleAncestor = '' + while path1 and path2: + anc1 = path1.pop() + anc2 = path2.pop() + if anc1 == anc2: + possibleAncestor= anc1 + else: + break + + return possibleAncestor + + + def pathToObject(self, idName): + path = [] + currentIdName= idName + while currentIdName != 'Object': + path.append(currentIdName) + currentIdName = self.types[currentIdName].parent + return path + ['Object'] + +class MyEncoder(json.JSONEncoder): + def default(self, obj): + return obj.toJSON() + +programContext = globalContext() + + +### Definition of basics classes + +#ObjClass = NodeClass(idName= 'Object', +# methods= [ +# NodeClassMethod( +# +# ) +# ], +# attributes= [ +# +# ], +# parent= None) diff --git a/src/compiler/components/semantic/semantic_analyzer.py b/src/compiler/components/semantic/semantic_analyzer.py new file mode 100644 index 00000000..cdd69a44 --- /dev/null +++ b/src/compiler/components/semantic/semantic_analyzer.py @@ -0,0 +1,35 @@ +from .type_builder import TypeBuilderVisitor +from .type_checker import TypeCheckerVisitor +from .type_inheritance import TypeInheritanceVisitor +from .type_collector import TypeCollectorVisitor +from .AST_definitions import NodeProgram +from .context import programContext, Attribute + + + +class semanticAnalyzer: + def __init__(self, ast: NodeProgram, + programContext): + self.ast = ast + self.errors = [] + self.programContext= programContext + + def run_visits(self: NodeProgram): + typeCollectorResult= TypeCollectorVisitor(self.programContext).visit(self.ast) + if typeCollectorResult: + self.errors += typeCollectorResult + return + typeBuilderResult= TypeBuilderVisitor(self.programContext).visit(self.ast) + if typeBuilderResult: + self.errors += typeBuilderResult + return + typeInheritanceResult= TypeInheritanceVisitor(self.programContext).visit(self.ast) + if typeInheritanceResult: + self.errors += typeInheritanceResult + return + typeCheckerResult, mapExprWithResult= TypeCheckerVisitor(self.programContext).visit(self.ast) + if typeCheckerResult: + self.errors += typeCheckerResult + return + + self.mapExprWithResult = mapExprWithResult \ No newline at end of file diff --git a/src/compiler/components/semantic/type_builder.py b/src/compiler/components/semantic/type_builder.py new file mode 100644 index 00000000..c4a3d6de --- /dev/null +++ b/src/compiler/components/semantic/type_builder.py @@ -0,0 +1,46 @@ +from .AST_definitions import * +from compiler.utils.visitors_definitions import NodeVisitor +from compiler.utils.errors import error + + +class TypeBuilderVisitor(NodeVisitor): + def __init__(self, programContext): + super().__init__(programContext) + self.currentTypeName = '' + + def visit_NodeProgram(self, node: NodeProgram): + errors = [] + for nodeClass in node.class_list: + errors += self.visit(nodeClass) + return errors + + def visit_NodeClass(self, node: NodeClass): + errors= [] + self.currentTypeName= node.idName + + for nodeAttr in node.attributes: + errors += self.visit(nodeAttr) + for nodeClassMethod in node.methods: + errors += self.visit(nodeClassMethod) + return errors + + def visit_NodeAttr(self, node: NodeAttr): + resultOp= self.programContext.defineAttrInType(self.currentTypeName, + node) + + if type (resultOp) is error: + return [resultOp] + + return [] + + def visit_NodeClassMethod(self, node: NodeClassMethod): + return [definition for definition in + [self.programContext.getType(node.returnType, (node.line, node.column))] + + [self.programContext.getType(idName = formal_param._type, row_and_col= (formal_param.line, formal_param.column)) for formal_param in node.formal_param_list] + + [self.programContext.defineMethod( + typeName = self.currentTypeName, + node= node + )] + if type(definition) is error + ] + diff --git a/src/compiler/components/semantic/type_checker.py b/src/compiler/components/semantic/type_checker.py new file mode 100644 index 00000000..088c43df --- /dev/null +++ b/src/compiler/components/semantic/type_checker.py @@ -0,0 +1,413 @@ +from .AST_definitions import * +from compiler.utils.visitors_definitions import NodeVisitor +from compiler.utils.errors import error + + +class TypeCheckerVisitor(NodeVisitor): + + + def visit_NodeProgram(self, node: NodeProgram): + self.mapExprWithType= {} + errors = [] + for nodeClass in node.class_list: + environment = self.programContext.buildEnv (typeName= nodeClass.idName) + errors += self.visit(nodeClass, previousEnv= environment) + + return errors, self.mapExprWithType + + def visit_NodeClass(self, node: NodeClass, previousEnv): + errors = [] + for nodeAttr in node.attributes: + result= self.visit(nodeAttr, previousEnv= previousEnv) + if type(result) is error: + errors.append(result) + + + for nodeClassMethod in node.methods: + result= self.visit(nodeClassMethod, previousEnv= previousEnv) + if type(result) is error: + errors.append(result) + + return errors + + def visit_NodeClassMethod(self, node: NodeClassMethod, previousEnv): + newEnv = self.programContext.buildEnvForMethod(node, previousEnv) + if type(newEnv) is error: + return newEnv + + typeResult = self.visit(node.body, previousEnv= newEnv) + + if type(typeResult) is error: + return typeResult + + return self.programContext.checkReturnType(node.returnType, + typeResult, + (node.line, node.column), + 'uncompatible types') + + def visit_NodeString(self, node: NodeString, **kwargs): + return 'String' + + def visit_NodeAttr(self, node: NodeAttr, previousEnv): + if node.expr: + typeExpr= self.visit(node.expr, + previousEnv= previousEnv) + if type(typeExpr) is error: + return typeExpr + + resultCheckAssign= self.programContext.checkAssign(nameObject= node.idName, + nodeType= node._type, + returnType= typeExpr, + row_and_col= (node.expr.line, node.expr.column) + if node.expr else (node.line, node.column), + errorOption= 'uncompatible assign attr') + if type(resultCheckAssign) is error: + return resultCheckAssign + + return node._type + + def visit_NodeLetComplex(self, + node: NodeLetComplex, + previousEnv: dict): + newEnv= previousEnv.copy() + for nodeLet in node.nestedLets: + + result= self.visit(nodeLet, + previousEnv= newEnv) + if type(result) is error: + return result + newEnv.update({ + nodeLet.idName: result + }) + + result= self.visit( node.body, + previousEnv= newEnv) + + return result + + def visit_NodeLet(self, node: NodeLet, previousEnv): + errors= [] + exprType= self.visit(node.body, + previousEnv= previousEnv) if node.body else node.type + if type(exprType) is error: + return exprType + + row_and_col = (node.body.line, node.body.column) if node.body else (node.line, node.column) + + resultCheckAssign= self.programContext.checkAssign(node.idName, + node.type, + exprType, + row_and_col, + 'uncompatible assing object', + node.column) + if type(resultCheckAssign) is error: + return resultCheckAssign + + return node.type + + def visit_NodeAssignment(self, node: NodeAssignment, + previousEnv): + + resultObj = self.visit(node.nodeObject, previousEnv= previousEnv) + + if type(resultObj) is error: + return resultObj + + resultExpr = self.visit(node.expr, previousEnv= previousEnv) + + if type(resultExpr) is error: + return resultExpr + + + resultCheckAssign= self.programContext.checkAssign(nameObject= node.nodeObject.idName, + nodeType= resultObj, + returnType= resultExpr, + row_and_col= (node.nodeObject.line, node.nodeObject.column ), + errorOption= 'uncompatible assing object', + columnAssign= node.columnAssign) + if type(resultCheckAssign) is error: + return resultCheckAssign + + return resultExpr + + def visit_NodeBinaryOperation(self, + node: NodeBinaryOperation, + previousEnv): + + + typeFirstExpr= self.visit(node.first, + previousEnv= previousEnv) + + typeSecondExpr= self.visit(node.second, + previousEnv= previousEnv) + + if type (typeFirstExpr) is error: + return typeFirstExpr + + if type (typeSecondExpr) is error: + return typeSecondExpr + + if type(node) is NodeEqual: + return self.programContext.checkEqualOp(typeFirstExpr, + typeSecondExpr, + (node.line, node.column)) + + + arithmeticOp = type(node) in {NodeAddition, + NodeSubtraction, + NodeDivision, + NodeMultiplication} + + + return self.programContext.checkArithmetic(typeFirstExpr, + typeSecondExpr, + (node.line, node.column), + node.symbol, + arithmeticOp) + + + + def visit_NodeNewObject(self, node: NodeNewObject, **kwargs): + result = self.programContext.getType(node.type, + row_and_col=(node.line, node.column)) + if type(result) is error: + return result + return node.type + + def visit_NodeExpr(self, + node: NodeExpr, + previousEnv): + return self.visit(node, previousEnv= previousEnv) + + + def visit_NodeInteger(self, + node: NodeInteger, + **kwargs): + return 'Int' + + def visit_NodeBoolean(self, + node: NodeBoolean, + **kwargs): + return 'Bool' + + def visit_NodeBooleanComplement(self, + node: NodeBooleanComplement, + previousEnv): + typeExpr = self.visit(node.boolean_expr, previousEnv= previousEnv) + if type(typeExpr) is error: + return typeExpr + return self.programContext.checkReturnType(nodeType= "Bool", returnType= typeExpr, + row_and_col= (node.line, node.boolean_expr.column -2), + errorOption= 'bad not') + + + + + def visit_NodeObject(self, + node: NodeObject, + previousEnv): + if node.idName == 'self': + return previousEnv['wrapperType'] + return self.programContext.searchValue(node, + (node.line, node.column), + previousEnv) + + def visit_NodeDynamicDispatch(self, + node: NodeDynamicDispatch, + previousEnv): + + typeExpr= self.visit(node.expr, + previousEnv= previousEnv) + if type (typeExpr) is error: + return typeExpr + + self.mapExprWithType[(node.line, node.column)]= typeExpr + methodInfo= self.programContext.checkMethodInType(idType= typeExpr, + idMethod = node.method, + row_and_col= (node.line, node.column + 1)) + if type(methodInfo) is error: + return methodInfo + + argTypes = [] + for arg in node.arguments: + currenttypeExpr= self.visit(arg, + previousEnv= previousEnv) + if type (currenttypeExpr) is error: + return currenttypeExpr + argTypes.append(currenttypeExpr) + + resultCheck= self.programContext.checkArgumentsInDispatch( + node, + methodInfo.argNames, + argTypes, + methodInfo.argTypes) + + if type(resultCheck) is error: + return resultCheck + + return methodInfo.returnType + + + def visit_NodeSelf(self, node: NodeSelf, previousEnv): + return previousEnv['wrapperType'] + + def visit_NodeIntegerComplement(self, node: NodeIntegerComplement, + previousEnv): + typeExpr = self.visit(node.integer_expr, previousEnv= previousEnv) + if type(typeExpr) is error: + return typeExpr + return self.programContext.checkReturnType(nodeType= "Int", returnType= typeExpr, + row_and_col= (node.line, node.column + 1), + errorOption= 'bad ~') + + def visit_NodeBlock(self, node: NodeBlock, previousEnv): + blockType = None + for expr in node.expr_list: + + blockType = self.visit(expr, previousEnv= previousEnv) + if type(blockType) is error: + return blockType + return blockType + + def visit_NodeIf(self, node: NodeIf, previousEnv): + predType = self.visit(node.predicate, previousEnv = previousEnv) + if type(predType) is error: + return predType + + resultCheck = self.programContext.checkReturnType(nodeType= 'Bool', returnType= predType, + row_and_col= (node.line, node.column), + errorOption= 'uncompatible types') + + if type(resultCheck) is error: + return resultCheck + + thenType = self.visit(node.then_body, previousEnv= previousEnv) + if type(thenType) is error: + return thenType + + elseType = self.visit(node.else_body, previousEnv= previousEnv) + if type(elseType) is error: + return elseType + + return self.programContext.LCA(idName1 = thenType, idName2= elseType) + + def visit_NodeCase(self, node: NodeCase, previousEnv): + resultTypeInit= self.visit(node.expr, previousEnv= previousEnv) + if type(resultTypeInit) is error: + return resultTypeInit + + return self.visit_NodeCaseActions(node.actions, + previousEnv, + resultTypeInit) + + def visit_NodeCaseActions(self, nodeActions, previousEnv, resultTypeInit): + + action, returnTypesExpressions= self.searchLessActionCaseAndReturnTypes(nodeActions, + previousEnv, + resultTypeInit) + if type(action) is error: + return action + + lca = returnTypesExpressions[0] + for typeExpr in returnTypesExpressions: + lca= self.programContext.LCA(idName1= lca, idName2= typeExpr) + + return lca + + def searchLessActionCaseAndReturnTypes(self, nodeActions, + previousEnv, resultTypeInit): + actionToReturn = None + currentTypeCase= 'Object' + returnTypesExpressions = [] + + resultCheckNonRepetition= self.programContext.checkNonRepetition(nodeActions) + if type(resultCheckNonRepetition) is error: + return resultCheckNonRepetition, None + + for action in nodeActions: + actionType= self.programContext.getType(idName= action.type, + row_and_col= (action.line, + action.column)) + if type(actionType) is error: + return actionType, None + + newEnv= previousEnv.copy() + newEnv.update({ + action.idName: action.type + }) + returnTypeAction= self.visit(action.expr, previousEnv= newEnv) + if type(returnTypeAction) is error: + return returnTypeAction, None + + returnTypesExpressions.append(returnTypeAction) + + if self.programContext.isSubtype(subType= resultTypeInit, + superType= action.type) and self.programContext.isSubtype( + subType= action.type, + superType= currentTypeCase): + actionToReturn= action + currentTypeCase= action.type + + return actionToReturn, returnTypesExpressions + + + def visit_NodeIsVoid(self, node: NodeIsVoid, previousEnv): + typeExpr= self.visit(node.expr, previousEnv = previousEnv) + if type(typeExpr) is error: + return typeExpr + return 'Bool' + + def visit_NodeStaticDispatch(self, node: NodeStaticDispatch, previousEnv): + typeLeftMost= self.visit(node.expr, previousEnv= previousEnv) + if type(typeLeftMost) is error: + return typeLeftMost + + dispatchType= self.programContext.getType(idName= node.dispatch_type, + row_and_col= (node.line, node.columnType)) + if type(dispatchType) is error: + return dispatchType + + methodInfo= self.programContext.checkMethodInType(idType= node.dispatch_type, + idMethod= node.method, + row_and_col= (node.line, node.columnIdMethod)) + if type(methodInfo) is error: + return methodInfo + + typeExprOfArgs = [] + for arg in node.arguments: + resultType= self.visit(node= arg, + previousEnv = previousEnv) + + if type(resultType) is error: + return resultType + + typeExprOfArgs.append(resultType) + + + checkingArgumentsResult= self.programContext.checkArgumentsInDispatch( + node, + methodInfo.argNames, + typeExprOfArgs, + methodInfo.argTypes,) + + if type(checkingArgumentsResult) is error: + return checkingArgumentsResult + + return self.programContext.checkDispatchTypes(typeLeftMost= typeLeftMost, + typeRight= dispatchType.idName, + returnType= methodInfo.returnType, + row_and_col= (node.expr.line, node.expr.column)) + + def visit_NodeWhileLoop(self, node: NodeWhileLoop, previousEnv): + resultExprPred = self.visit(node.predicate, previousEnv= previousEnv) + if type(resultExprPred) is error: + return resultExprPred + resultCheck = self.programContext.checkBoolInPredicate(node, resultExprPred) + if type(resultCheck) is error: + return resultCheck + + resultExpr = self.visit(node.body, previousEnv= previousEnv) + if type(resultExpr) is error: + return resultExpr + + return 'Object' diff --git a/src/compiler/components/semantic/type_collector.py b/src/compiler/components/semantic/type_collector.py new file mode 100644 index 00000000..3a938b93 --- /dev/null +++ b/src/compiler/components/semantic/type_collector.py @@ -0,0 +1,19 @@ +from .AST_definitions import * +from compiler.utils.visitors_definitions import NodeVisitor +from compiler.utils.errors import error + + +class TypeCollectorVisitor(NodeVisitor): + + def visit_NodeProgram(self, node: NodeProgram): + errors = [] + for nodeClass in node.class_list: + result= self.visit(nodeClass) + if type (result) is error: # This ugly return is because we only need a one error, this is the panic mode! + errors.append(result) + return errors + + + def visit_NodeClass(self, node: NodeClass): + # When we create a type, we store it in the context, if there is no errors + return self.programContext.createType(node) diff --git a/src/compiler/components/semantic/type_inheritance.py b/src/compiler/components/semantic/type_inheritance.py new file mode 100644 index 00000000..92cd3b65 --- /dev/null +++ b/src/compiler/components/semantic/type_inheritance.py @@ -0,0 +1,67 @@ +from .AST_definitions import * +from compiler.utils.visitors_definitions import NodeVisitor +from compiler.utils.errors import error + + +class TypeInheritanceVisitor(NodeVisitor): + + + def visit_NodeProgram(self, node: NodeProgram): + errors = [] + + for nodeClass in node.class_list: + result = self.programContext.checkGoodInheritance(nodeClass) + if type(result) is error: + errors.append(result) + + # This is because we need only one error to pass the tests. + if errors: + return [errors.pop()] + + self.programContext.actualizeChildren() + node.class_list= self.orderClassesByInhertiance('Object', node.class_list, + {node.idName: False for node in node.class_list}) + + for nodeClass in node.class_list: + result = self.visit(nodeClass) + if type(result) is error: + errors.append(result) + return [errors.pop()] if errors else [] + + def visit_NodeClass(self, node: NodeClass): + + if node.idName == 'Object': + return + + for nodeAttr in node.attributes: + resultVisitAttr= self.visit(nodeAttr, idType= node.idName) + if type(resultVisitAttr) is error: + return resultVisitAttr + + for nodeClassMethod in node.methods: + resultVisitClassMethod= self.visit(nodeClassMethod, idType= node.idName) + if type(resultVisitClassMethod) is error: + return resultVisitClassMethod + + self.programContext.actualizeInherits(node) + + + def visit_NodeAttr(self, node: NodeAttr, idType): + return self.programContext.checkNotOverwriteAttr(node, idType) + + + def visit_NodeClassMethod(self, node: NodeClassMethod, idType): + return self.programContext.checkGoodOverwriteMethod(node, idType) + + def orderClassesByInhertiance(self, typeName, classList, visitedDict): + order = [self.returnClassByIdName(typeName, classList)] + for child in self.programContext.types[typeName].children: + if not visitedDict[typeName]: + order += self.orderClassesByInhertiance(child, classList, visitedDict) + + visitedDict[typeName]= True + return order + + def returnClassByIdName(self, typeName, classList): + return next((_class for _class in classList if _class.idName == typeName), None) + diff --git a/src/compiler/utils/__init__.py b/src/compiler/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/compiler/utils/basics_AST.py b/src/compiler/utils/basics_AST.py new file mode 100644 index 00000000..621b6a2a --- /dev/null +++ b/src/compiler/utils/basics_AST.py @@ -0,0 +1,13 @@ +from compiler.components.lexer.lexer_analyzer import tokenizer, tokens +from compiler.components.parser.syntax_analyzer import run_parser + +def build_basic_ast(): + fpath = "./basics_classes.cl" + with open(fpath, encoding="utf-8") as file: + code = file.read() + _, _, real_col= tokenizer(code) + ast_basic= run_parser(tokens= tokens, + source_program= code, + real_col= real_col) + return ast_basic + diff --git a/src/compiler/utils/basics_classes.cl b/src/compiler/utils/basics_classes.cl new file mode 100644 index 00000000..94075b38 --- /dev/null +++ b/src/compiler/utils/basics_classes.cl @@ -0,0 +1,28 @@ +class Object { + abort(): Object { self }; + copy(): Object { self }; + type_name(): String { "" }; +}; + +class IO { + in_int(): Int { 0 }; + in_string(): String { "" }; + out_int(x: Int): IO { self }; + out_string(x: String): IO { self }; +}; + +class Int { +}; + +class Bool { +}; + +class String { + length(): Int { 0 }; + concat(s: String): String { "" }; + substr(i: Int, l: Int): String { "" }; +}; + + + + diff --git a/src/compiler/utils/config.py b/src/compiler/utils/config.py new file mode 100644 index 00000000..83ae33bd --- /dev/null +++ b/src/compiler/utils/config.py @@ -0,0 +1,95 @@ +TYPE_ERROR = "TypeError" +NAME_ERROR = "NameError" +ATTRIBUTE_ERROR = "AttributeError" +SEMANTIC_ERROR = "SemanticError" + +SELF_TYPE = "SELF_TYPE" +INT = "Int" +BOOL = "Bool" +STRING = "String" +OBJECT = "Object" +IO = "IO" + +ABORT = "abort" +COPY = "copy" +TYPE_NAME = "type_name" + +OUT_STRING = "out_string" +OUT_INT = "out_int" +IN_STRING = "in_string" +IN_INT = "in_int" + +LENGTH = "length" +CONCAT = "concat" +SUBSTR = "substr" + + +ABORT_SIGNAL = "abort_signal"#CIL +CASE_MISSMATCH = "case_missmatch"#CIL +CASE_VOID = "case_on_void"#MIPS +DISPATCH_VOID = "dispatch_on_void"#MIPS +ZERO_DIVISION = "division_by_zero"#MIPS +SUBSTR_OUT_RANGE = "substr_out_of_range"#MIPS +HEAP_OVERFLOW = "heap_overflow" + +#code_gen +WORD = ".word" +ASCIIZ = ".asciiz" +SPACE = ".space" + +t0 = "$t0" +t1 = "$t1" +t2 = "$t2" +t3 = "$t3" +t6 = "$t6" # convenios +t7 = "$t7" # convenios +a0 = "$a0" +a1 = "$a1" +fp = "$fp" +sp = "$sp" +ra = "$ra" +lo = "lo" +hi = "hi" +v0 = "$v0" +s0 = "$s0" +s1 = "$s1" +s2 = "$s2" +s3 = "$s3" +zero = "$zero" + +BUFFER_SIZE = 1024 +INSTANCE_EXTRA_FIELDS = 1 # just type_info +VTABLE_EXTRA_FIELDS = 3 # type_name, parent, size +FP_ARGS_DISTANCE = 3 # how far finishes $fp from arguments in method call +FP_LOCALS_DISTANCE = 0 # how far finishes $fp from localvars in method call +VOID = "void" +STR_CMP = "string_comparer" +EMPTY_STRING = "empty_string" +INPUT_STR_BUFFER = "input_str_buffer" +EXIT = "exit" + +TYPEINFO_ATTR_OFFSET = 0 + +#type_info offsets +TYPENAME_OFFSET = 0 +PARENT_OFFSET = 4 +SIZE_OFFSET = 8 + +#str attributes offsets +LENGTH_ATTR_OFFSET = 4 +CHARS_ATTR_OFFSET = 8 + +SYSCALL_PRINT_INT = 1 +SYSCALL_PRINT_STR = 4 +SYSCALL_READ_INT = 5 +SYSCALL_READ_STR = 8 +SYSCALL_SBRK = 9 +SYSCALL_EXIT = 10 + +RA_OFFSET = 4 +OLD_FP_OFFSET = 8 +SELF_OFFSET = 12 + +BOX_SIZE = 8 +BOXED_VALUE_OFFSET = 4 +STRING_SIZE = 12 \ No newline at end of file diff --git a/src/compiler/utils/errors.py b/src/compiler/utils/errors.py new file mode 100644 index 00000000..5da51633 --- /dev/null +++ b/src/compiler/utils/errors.py @@ -0,0 +1,166 @@ +class error: + def __init__(self, error_type, row_and_col, message): + self.error_type = error_type + self.row_and_col = row_and_col + self.message = message + + def __str__(self): + return '(%d, %d) - %s: %s' %(self.row_and_col[0], self.row_and_col[1], self.error_type, self.message) + + __repr__ = __str__ + + +errorSelector = {'repeated class basic': lambda idName, row_and_col=(0,0):error( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= 'Redefinition of basic class %s' %idName + ), + 'repeated class': lambda idName, row_and_col=(0,0):error( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= 'Redefinition of basic class %s' %idName + ), + 'undefined type': lambda idName, row_and_col=(0,0):error( + error_type='TypeError', + row_and_col= row_and_col, + message= "The type %s doesn't exist in the current context" %idName, + ), + 'undefined type in attr': lambda idAttr, idBadType, row_and_col= (0,0): error ( + error_type='TypeError', + row_and_col= row_and_col, + message= 'Class %s of attribute %s is undefined.' %(idBadType, idAttr) + ), + 'uncompatible types': lambda type1, type2, row_and_col= (0,0): error ( + error_type='TypeError', + row_and_col= row_and_col, + message= 'Bad assign %s to %s' %(type1, type2) + ), + 'repeated attr': lambda idName, row_and_col=(0,0):error( + error_type='SemanticError', + row_and_col=row_and_col, + message="Attribute %s is multiply defined in class." %idName + ), + 'repeated method': lambda idName, row_and_col=(0,0):error( + error_type='SemanticError', + row_and_col=row_and_col, + message="Method %s is multiply defined." %idName + ), + 'built-in inheritance': lambda idName, idParent, row_and_col=(0,0): error ( + error_type='SemanticError', + row_and_col=row_and_col, + message="Class %s cannot inherit class %s." %(idName, idParent) + ), + 'inheritance from child': lambda idChild, row_and_col=(0,0): error ( + error_type='SemanticError', + row_and_col=row_and_col, + message="Class %s, or an ancestor of %s, is involved in an inheritance cycle." %(idChild, idChild) + ), + 'undefined method in class': lambda idName, className, row_and_col=(0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message="The class %s has no method called %s" %(idName, className) + ), + 'undefined arguments for method in class': lambda idName, className, undefinedArgs, row_and_col=(0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message="The arguments %s does not exists in method %s in class %s " %(undefinedArgs, idName, className) + ), + 'arithmetic fail': lambda type1, type2, symbolOp, row_and_col=(0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message="non-Int arguments: %s %s %s." %(type1, symbolOp, type2) + ), + 'undefined symbol': lambda symbolName, row_and_col=(0,0): error ( + error_type= 'NameError', + row_and_col= row_and_col, + message="Undeclared identifier %s." %symbolName + ), + 'not ancestor in dispatch': lambda idName, returnType, row_and_col=(0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message= 'Type %s is not subtype of %s at %s.' %(idName, returnType, row_and_col) + ), + 'comparison fail': lambda row_and_col= (0,0): error( + error_type= 'TypeError', + row_and_col=row_and_col, + message= 'Illegal comparison with a basic type.' + ), + 'uncompatible assing object': lambda idName, type1, type2, row_and_col = (0,0) : error ( + error_type='TypeError', + row_and_col= row_and_col, + message= "Inferred type %s of initialization of %s does not conform to identifier's declared type %s." %(type1, idName, type2) + ), + 'self parameter': lambda row_and_col = (0,0) : error ( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= "'self' cannot be the name of a formal parameter." + ), + 'boolean fail': lambda type1, type2, row_and_col=(0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message="non-Bool arguments: %s + %s." %(type1, type2) + ), + 'uncompatible assign attr': lambda idName, type1, type2, row_and_col = (0,0): error ( + error_type='TypeError', + row_and_col= row_and_col, + message="Inferred type %s of initialization of attribute %s does not conform to declared type %s" %( type1, idName, type2) + ), + 'bad ~': lambda type1, type2, row_and_col = (0,0): error ( + error_type='TypeError', + row_and_col= row_and_col, + message="Argument of '~' has type %s instead of %s." %( type1, type2) + ), + 'bad not': lambda type1, type2, row_and_col = (0,0): error ( + error_type='TypeError', + row_and_col= row_and_col, + message="Argument of 'not' has type %s instead of %s." %( type1, type2) + ), + 'not method in class': lambda idMethod, row_and_col= (0,0): error ( + error_type='AttributeError', + row_and_col= row_and_col, + message= "Dispatch to undefined method %s." %(idMethod) + ), + 'bad dispatch': lambda idMethod, badType, badArg, realType, row_and_col= (0,0): error( + error_type='TypeError', + row_and_col= row_and_col, + message= "In call of method %s, type %s of parameter %s does not conform to declared type %s." %(idMethod, badType, badArg, realType) + ), + 'bad static dispatch': lambda typeLef, typeRight, row_and_col= (0,0): error( + error_type='TypeError', + row_and_col= row_and_col, + message="Expression type %s does not conform to declared static dispatch type %s." %(typeLef, typeRight) + ), + 'self assign': lambda row_and_col= (0,0): error ( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= "Cannot assign to 'self'." + ), + 'bad predicate': lambda row_and_col= (0,0): error ( + error_type= 'TypeError', + row_and_col= row_and_col, + message= 'Loop condition does not have type Bool.' + ), + 'bad redefine method': lambda methodName, badType, goodType, row_and_col= (0,0): error( + error_type= 'SemanticError', + row_and_col= row_and_col, + message ='In redefined method %s, parameter type %s is different from original type %s.' %(methodName, badType, goodType) + ), + 'bad returnType in redefine method': lambda methodName, badType, goodType, row_and_col= (0,0): error ( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= 'In redefined method %s, return type %s is different from original return type %s.' %(methodName, badType, goodType) + ), + 'bad length in redefine': lambda methodName, row_and_col= (0,0): error ( + error_type='SemanticError', + row_and_col= row_and_col, + message= 'Incompatible number of formal parameters in redefined method %s.' %(methodName) + ), + 'bad redefine attr': lambda badAttr, row_and_col= (0,0) : error( + error_type= 'SemanticError', + row_and_col= row_and_col, + message= 'Attribute %s is an attribute of an inherited class.' %(badAttr) + ) + } + +def interceptError(validationFunc, errorOption: str, **argumentsConstructor): + return (not validationFunc()) and errorSelector[errorOption](**argumentsConstructor) diff --git a/src/compiler/utils/lexer_definitions.py b/src/compiler/utils/lexer_definitions.py new file mode 100644 index 00000000..77c27e4e --- /dev/null +++ b/src/compiler/utils/lexer_definitions.py @@ -0,0 +1,267 @@ +from ply.lex import TOKEN + +tokens_collection = ( + # Identifiers + "ID", "TYPE", + + # Primitive Types + "INTEGER", "STRING", "BOOLEAN", + + # Literals + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "COLON", "COMMA", "DOT", "SEMICOLON", "AT", + + # Operators + "PLUS", "MINUS", "MULTIPLY", "DIVIDE", "EQ", "LT", "LTEQ", "ASSIGN", "INT_COMP", "NOT", + + # Special Operators + "ARROW" +) + +class keyword(str): + def __eq__(self, other: str): + val = str(self) + if val != 'true' and val != 'false': + return val == other.lower() + return val[0] == other[0] and val[1:] == other.lower()[1:] + def __hash__(self): + return super().__hash__() + +basic_keywords = { + "case": keyword("case"), + "class": keyword("class"), + "else": keyword("else"), + "esac": keyword("esac"), + "fi": keyword("fi"), + "if": keyword("if"), + "in": keyword("in"), + "inherits": keyword("inherits"), + "isvoid": keyword("isvoid"), + "let": keyword("let"), + "loop": keyword("loop"), + "new": keyword("new"), + "of": keyword("of"), + "pool": keyword("pool"), + "self": keyword("self"), + "then": keyword("then"), + "while": keyword("while"), + "true": keyword("true"), + "false": keyword("false"), + 'not' : keyword('not') +} + +#Simple rules for cool +t_LPAREN = r'\(' # ( +t_RPAREN = r'\)' # ) +t_LBRACE = r'\{' # { +t_RBRACE = r'\}' # } +t_COLON = r'\:' # : +t_COMMA = r'\,' # , +t_DOT = r'\.' # . +t_SEMICOLON = r'\;' # ; +t_AT = r'\@' # @ +t_PLUS = r'\+' # + +t_MINUS = r'\-' # - +t_MULTIPLY = r'\*' # * +t_DIVIDE = r'\/' # / +t_EQ = r'\=' # = +t_LT = r'\<' # < +t_LTEQ = r'\<\=' # <= +t_ASSIGN = r'\<\-' # <- +t_INT_COMP = r'~' # ~ +t_NOT = r'not' # not + +#ignore spaces +t_ignore = ' \t\r\f' + +simple_rules = { + 't_LPAREN': t_LPAREN, + 't_RPAREN': t_RPAREN, + 't_LBRACE': t_LBRACE, + 't_RBRACE': t_RBRACE, + 't_COLON': t_COLON, + 't_COMMA': t_COMMA, + 't_DOT': t_DOT, + 't_SEMICOLON': t_SEMICOLON, + 't_AT': t_AT, + 't_PLUS': t_PLUS, + 't_MINUS': t_MINUS, + 't_MULTIPLY': t_MULTIPLY, + 't_DIVIDE': t_DIVIDE, + 't_EQ': t_EQ, + 't_LT': t_LT, + 't_LTEQ': t_LTEQ, + 't_ASSIGN': t_ASSIGN, + 't_INT_COMP': t_INT_COMP, + 't_NOT': t_NOT, + 't_ignore' : t_ignore +} + + +#Complex rules for cool + +@TOKEN(r"(true|false)") +def t_BOOLEAN (token): + token.value = True if token.value == basic_keywords['true'] else False + return token + +@TOKEN(r"\d+") +def t_INTEGER(token): + token.value = int(token.value) + return token + +@TOKEN(r"[A-Z][a-zA-Z_0-9]*") +def t_TYPE(token): + token.type = basic_keywords.get(token.value, 'TYPE') + return token + +@TOKEN(r"\n+") +def t_newline(token): + token.lexer.lineno += len(token.value) + + +@TOKEN(r"[a-z][a-zA-Z_0-9]*") +def t_ID(token): + token.type = basic_keywords.get(token.value, 'ID') + return token + + + +#Lexer states +def states(): + return ( + ("STRING", "exclusive"), + ("COMMENT", "exclusive") + ) + +# The string states + +@TOKEN(r"\"") +def t_STRING_start(token): + token.lexer.push_state("STRING") + token.lexer.string_backslashed = False + token.lexer.stringbuf = "" + + +@TOKEN(r"\n") +def t_STRING_newline(token): + token.lexer.lineno += 1 + if not token.lexer.string_backslashed: + print("String newline not escaped") + token.lexer.skip(1) + else: + token.lexer.string_backslashed = False + + +@TOKEN(r"\"") +def t_STRING_end(token): + if not token.lexer.string_backslashed: + token.lexer.pop_state() + token.value = token.lexer.stringbuf + token.type = "STRING" + return token + else: + token.lexer.stringbuf += '"' + token.lexer.string_backslashed = False + +@TOKEN(r"[^\n]") +def t_STRING_anything( token): + if token.lexer.string_backslashed: + if token.value == 'b': + token.lexer.stringbuf += '\b' + elif token.value == 't': + token.lexer.stringbuf += '\t' + elif token.value == 'n': + token.lexer.stringbuf += '\n' + elif token.value == 'f': + token.lexer.stringbuf += '\f' + elif token.value == '\\': + token.lexer.stringbuf += '\\' + else: + token.lexer.stringbuf += token.value + token.lexer.string_backslashed = False + else: + if token.value != '\\': + token.lexer.stringbuf += token.value + else: + token.lexer.string_backslashed = True + + +# STRING ignored characters +t_STRING_ignore = '' + + + + + + +# The comment states +@TOKEN(r"\(\*") +def t_COMMENT_start(token): + token.lexer.push_state("COMMENT") + token.lexer.comment_count = 0 + +#Comments can be recursive +@TOKEN(r"\(\*") +def t_COMMENT_startanother(t): + t.lexer.comment_count += 1 + +@TOKEN(r"\*\)") +def t_COMMENT_end(token): + if token.lexer.comment_count == 0: + token.lexer.pop_state() + else: + token.lexer.comment_count -= 1 + + +t_ignore_SINGLE_LINE_COMMENT = r"\-\-[^\n]*" + + + + + +#Error handlers +#(4, 2) - LexicographicError: ERROR "!" +# STRING error handler +def t_STRING_error( token): + print('({0}, {1}) - LexicographicError: ERROR "{2}"'.format(token.lineno, token.lexpos, token.value[0])) + token.lexer.skip(1) + +#(55, 46) - LexicographicError: EOF in comment +# COMMENT error handler +def t_COMMENT_error( token): + print("({0}, {1}) - LexicographicError: EOF in comment".format(token.lineno, token.lexpos)) + token.lexer.skip(1) + + +def t_error( token): + print('({0}, {1}) - LexicographicError: ERROR "{2}"'.format(token.lineno, token.lexpos, token.value[0])) + token.lexer.skip(1) + + + +#Complex rules list +complex_rules = { + 't_BOOLEAN': t_BOOLEAN, + 't_INTEGER': t_INTEGER, + 't_TYPE': t_TYPE, + 't_newline': t_newline, + 't_ID': t_ID, + #---------- + #String states rules + 't_STRING_start': t_STRING_start, + 't_STRING_newline': t_STRING_newline, + 't_STRING_anything': t_STRING_anything, + 't_STRING_end': t_STRING_end, + #---------- + #Comment states rules + 't_COMMENT_start': t_COMMENT_start, + 't_COMMENT_startanother': t_COMMENT_startanother, + 't_COMMENT_end': t_COMMENT_end, +} +#Error handlers +error_handlers = { + 't_STRING_error': t_STRING_error, + 't_COMMENT_error': t_COMMENT_error, + 't_error': t_error +} + diff --git a/src/compiler/utils/preprocess_input.py b/src/compiler/utils/preprocess_input.py new file mode 100644 index 00000000..7a167149 --- /dev/null +++ b/src/compiler/utils/preprocess_input.py @@ -0,0 +1,8 @@ +def replace_tabs(_input, tabstop= 4): + result = '' + for c in _input: + if c =='\t': + result += ' ' * 4 + else: + result += c + return result \ No newline at end of file diff --git a/src/compiler/utils/visitors_definitions.py b/src/compiler/utils/visitors_definitions.py new file mode 100644 index 00000000..b00e146b --- /dev/null +++ b/src/compiler/utils/visitors_definitions.py @@ -0,0 +1,23 @@ +from ..components.semantic.AST_definitions import * + + +from compiler.utils.errors import error + + +class NodeVisitor: + def __init__(self, programContext): + self.programContext= programContext + + def visit(self, node: Node, **args): + if self.__class__.__name__ == 'TypeCheckerVisitor': + if issubclass(type(node), NodeBinaryOperation): + return self.visit_NodeBinaryOperation(node, **args) + + visitor_method_name = 'visit_' + node.clsname + visitor = getattr(self, visitor_method_name, self.not_implemented) + return visitor(node, **args) # Return the new context result from the visit + + def not_implemented(self, node: Node, **args): + raise Exception('Not implemented visit_{} method'.format(node.clsname)) + + diff --git a/src/coolc.sh b/src/coolc.sh index 3088de4f..73f7fd95 100755 --- a/src/coolc.sh +++ b/src/coolc.sh @@ -1,11 +1,20 @@ # Incluya aquí las instrucciones necesarias para ejecutar su compilador + INPUT_FILE=$1 OUTPUT_FILE=${INPUT_FILE:0: -2}mips + +#El compilador va a ser un py. +#Aquí llamamos al compilador con los valores de la entrada estándar. + + + # Si su compilador no lo hace ya, aquí puede imprimir la información de contacto -echo "LINEA_CON_NOMBRE_Y_VERSION_DEL_COMPILADOR" # TODO: Recuerde cambiar estas -echo "Copyright (c) 2019: Nombre1, Nombre2, Nombre3" # TODO: líneas a los valores correctos +echo "DiazRock_CoolCompiler.V1.0" # TODO: Recuerde cambiar estas +echo "CopyLeft (L) 2020: Alejandro Díaz Roque, Rafael Horrach" # Llamar al compilador -echo "Compiling $INPUT_FILE into $OUTPUT_FILE" +python3 main.py "$@" +#echo "Compiling $INPUT_FILE into $OUTPUT_FILE" + diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..41529cb0 --- /dev/null +++ b/src/main.py @@ -0,0 +1,115 @@ +import sys, fileinput, os +from argparse import ArgumentParser +from compiler.components.lexer.lexer_analyzer import tokenizer, tokens +from compiler.components.parser.syntax_analyzer import run_parser +from compiler.components.semantic.semantic_analyzer import semanticAnalyzer +from compiler.components.semantic.context import programContext +from compiler.components.generation.CIL_generator import CILVisitor +#from compiler.utils.basics_AST import build_basic_ast +from compiler.utils.preprocess_input import replace_tabs +from compiler.components.generation.MIPS_generator import MipsVisitor +import compiler.components.semantic.AST_definitions as ast +import subprocess as sp + +def build_basic_ast(): + fpath = "./compiler/utils/basics_classes.cl" + with open(fpath, encoding="utf-8") as file: + code = file.read() + _, _, real_col_basic= tokenizer(code) + ast_basic,_= run_parser(tokens= tokens, + source_program= code, + real_col= real_col_basic) + for _class in ast_basic.class_list: + if _class.idName == 'Int' or _class.idName == 'Bool': + _class.attributes.append(ast.NodeAttr(idName = '_val', + _type= '__prim_zero_slot', + line= 0, column= 0)) + if _class.idName== 'String': + _class.attributes.append(ast.NodeAttr(idName = '_val', + _type= 'Int', + line= 0, column= 0)) + _class.attributes.append(ast.NodeAttr(idName = '_str_field', + _type= '__prim_empty_slot', + line= 0, column= 0)) + + return ast_basic + +parser_input = ArgumentParser(description= 'This is the Diaz-Horrach cool compiler, an school project.\nRead this help and see the ofitial repo') +parser_input.add_argument('files_for_compile', help = 'The file(s) to be compiled', nargs= '+') +parser_input.add_argument('--test', help = 'Indicates if the compiling is for test', action="store_true") +""" parser_input.add_argument("--lexer", help = 'Select the lexer that you could use from avialable options', choices = component_injector['lexer_options'].keys(), + default='cool') +parser_input.add_argument("--parser", help = 'Select the lexer that you could use from avialable options', choices = component_injector['parser_options'].keys()) +parser_input.add_argument("--output", help = 'Put the info of the selected components in the standard output.', choices = ['l','p','t']) + """ + + + +args= parser_input.parse_args() +file= open(args.files_for_compile[0]) +working_input= file.read() +working_input_with_no_tabs = replace_tabs(working_input) + + +all_errors= [] +token_errors, tokens_for_input, real_col= tokenizer(working_input_with_no_tabs) + +if token_errors: + for error in token_errors: + print(error) + exit(1) + + +ast_result, parser_errors= run_parser(tokens, + working_input_with_no_tabs, + real_col) + +if parser_errors: + for error in parser_errors: + print(error) + exit(1) + + +basic_ast= build_basic_ast() +# Adding the builtIn classes +ast_result.class_list= basic_ast.class_list + ast_result.class_list + +# Running semantic analyzer +sa = semanticAnalyzer(ast_result, programContext) +sa.run_visits() + + +all_errors += token_errors + parser_errors + sa.errors + +if all_errors: + for error in all_errors: + print(error) + exit(1) + + +# Running code generation + +cilGen= CILVisitor(programContext, mapExpr= sa.mapExprWithResult) +programResult= cilGen.visit(sa.ast) + +mipsGen= MipsVisitor(programContext) + +mipsCode= mipsGen.visit(programResult) + + +# Saving the compiling +filePath= args.files_for_compile[0] + +fileToWritePath= filePath[:filePath.rfind('.') + 1] + 'mips' + +with open(fileToWritePath, 'w', encoding="utf-8") as file: + stream = '#Compiled by DiazRock COOL compiler\n' + for line in mipsCode: + stream += line + + file.write(stream) + if args.test: + pathTest= filePath[ :filePath.rfind('.') ] + '_input.txt' + spim= 'spim -f ' + fileToWritePath + os.system('cat "{}"|{} '.format(pathTest, spim) ) + diff --git a/src/makefile b/src/makefile index 30df993f..04aa1cf4 100644 --- a/src/makefile +++ b/src/makefile @@ -10,3 +10,4 @@ clean: test: pytest ../tests -v --tb=short -m=${TAG} + diff --git a/tests/codegen/arith.mips b/tests/codegen/arith.mips new file mode 100644 index 00000000..840221a2 --- /dev/null +++ b/tests/codegen/arith.mips @@ -0,0 +1,18970 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n\tTo add a number to " + data_2: .align 2 + .asciiz "...enter a:\n" + data_3: .align 2 + .asciiz "\tTo negate " + data_4: .align 2 + .asciiz "...enter b:\n" + data_5: .align 2 + .asciiz "\tTo find the difference between " + data_6: .align 2 + .asciiz "and another number...enter c:\n" + data_7: .align 2 + .asciiz "\tTo find the factorial of " + data_8: .align 2 + .asciiz "...enter d:\n" + data_9: .align 2 + .asciiz "\tTo square " + data_10: .align 2 + .asciiz "...enter e:\n" + data_11: .align 2 + .asciiz "\tTo cube " + data_12: .align 2 + .asciiz "...enter f:\n" + data_13: .align 2 + .asciiz "\tTo find out if " + data_14: .align 2 + .asciiz "is a multiple of 3...enter g:\n" + data_15: .align 2 + .asciiz "\tTo divide " + data_16: .align 2 + .asciiz "by 8...enter h:\n" + data_17: .align 2 + .asciiz "\tTo get a new number...enter j:\n" + data_18: .align 2 + .asciiz "\tTo quit...enter q:\n\n" + data_19: .align 2 + .asciiz "\n" + data_20: .align 2 + .asciiz "Please enter a number... " + data_21: .align 2 + .asciiz "Class type is now E\n" + data_22: .align 2 + .asciiz "Class type is now C\n" + data_23: .align 2 + .asciiz "Class type is now D\n" + data_24: .align 2 + .asciiz "Class type is now B\n" + data_25: .align 2 + .asciiz "Class type is now A\n" + data_26: .align 2 + .asciiz "Oooops\n" + data_27: .align 2 + .asciiz " " + data_28: .align 2 + .asciiz "number " + data_29: .align 2 + .asciiz "is odd!\n" + data_30: .align 2 + .asciiz "is even!\n" + data_31: .align 2 + .asciiz "a" + data_32: .align 2 + .asciiz "b" + data_33: .align 2 + .asciiz "c" + data_34: .align 2 + .asciiz "d" + data_35: .align 2 + .asciiz "e" + data_36: .align 2 + .asciiz "f" + data_37: .align 2 + .asciiz "g" + data_38: .align 2 + .asciiz "h" + data_39: .align 2 + .asciiz "j" + data_40: .align 2 + .asciiz "q" + data_41: .align 2 + .asciiz "is equal to " + data_42: .align 2 + .asciiz "times 8 with a remainder of " + data_43: .align 2 + .asciiz "is not divisible by 3.\n" + data_44: .align 2 + .asciiz "is divisible by 3.\n" + data_45: .align 2 + .asciiz "Abort called from class Main\n" + data_46: .align 2 + .asciiz "0" + data_47: .align 2 + .asciiz "1" + data_48: .align 2 + .asciiz "2" + data_49: .align 2 + .asciiz "3" + data_50: .align 2 + .asciiz "4" + data_51: .align 2 + .asciiz "5" + data_52: .align 2 + .asciiz "6" + data_53: .align 2 + .asciiz "7" + data_54: .align 2 + .asciiz "8" + data_55: .align 2 + .asciiz "9" + data_56: .align 2 + .asciiz "Abort called from class A2I\n" + data_57: .align 2 + .asciiz "-" + data_58: .align 2 + .asciiz "+" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_A: .align 2 + .asciiz "A" + classname_B: .align 2 + .asciiz "B" + classname_C: .align 2 + .asciiz "C" + classname_D: .align 2 + .asciiz "D" + classname_E: .align 2 + .asciiz "E" + classname_A2I: .align 2 + .asciiz "A2I" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 52 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_A + sw $t1 28($s1) + la $t1 classname_B + sw $t1 32($s1) + la $t1 classname_C + sw $t1 36($s1) + la $t1 classname_D + sw $t1 40($s1) + la $t1 classname_E + sw $t1 44($s1) + la $t1 classname_A2I + sw $t1 48($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 104 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 28 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 28 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type A + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type B + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type C + li $a0 16 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type D + li $a0 16 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 80($s0) + + # Type E + li $a0 16 + li $v0 9 + syscall + li $a0 11 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 88($s0) + + # Type A2I + li $a0 12 + li $v0 9 + syscall + li $a0 12 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 96($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 56 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_menu + sw $t1 28($v0) + la $t1 function_Main_prompt + sw $t1 32($v0) + la $t1 function_Main_get_int + sw $t1 36($v0) + la $t1 function_Main_is_even + sw $t1 40($v0) + la $t1 function_Main_class_type + sw $t1 44($v0) + la $t1 function_Main_print + sw $t1 48($v0) + la $t1 function_Main_main + sw $t1 52($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type A + li $a0 40 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_A_method5 + sw $t1 36($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type B + li $a0 40 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type C + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_C_method5 + sw $t1 36($v0) + la $t1 function_C_method6 + sw $t1 40($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type D + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + la $t1 function_D_method7 + sw $t1 40($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + # Type E + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + la $t1 function_D_method7 + sw $t1 40($v0) + la $t1 function_E_method6 + sw $t1 44($v0) + lw $t0 88($s0) + sw $v0 8($t0) + + # Type A2I + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A2I_c2i + sw $t1 12($v0) + la $t1 function_A2I_i2c + sw $t1 16($v0) + la $t1 function_A2I_a2i + sw $t1 20($v0) + la $t1 function_A2I_a2i_aux + sw $t1 24($v0) + la $t1 function_A2I_i2a + sw $t1 28($v0) + la $t1 function_A2I_i2a_aux + sw $t1 32($v0) + lw $t0 96($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 52 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 12 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 7 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 8 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 8 + sw $t1 0($t0) + + li $t0 11 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 10 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 24($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_menu: + move $fp, $sp + subu $sp, $sp, 392 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 32 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -96($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -112($fp) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -124($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -140($fp) + la $a0, data_7 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -140($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -132($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -132($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + lw $a2, -132($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -156($fp) + + # PUSHPARAM + lw $a0, -156($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + lw $a0 -172($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -168($fp) + la $a0, data_8 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -168($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -160($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -160($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + lw $a2, -160($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_9 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -184($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -200($fp) + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -192($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -192($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + lw $a2, -192($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + lw $a0 -216($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -212($fp) + la $a0, data_10 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -212($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -204($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -204($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + lw $a2, -204($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + li $a0, 9 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -232($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -228($fp) + la $a0, data_11 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -228($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -220($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -220($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + lw $a2, -220($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -244($fp) + + # PUSHPARAM + lw $a0, -244($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -236($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -236($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + lw $a2, -236($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_12 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -256($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_13 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -272($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -264($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -264($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + lw $a2, -264($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -288($fp) + + # PUSHPARAM + lw $a0, -288($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -280($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -280($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + lw $a2, -280($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -300($fp) + la $a0, data_14 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -300($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -292($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -292($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + lw $a2, -292($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -320($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -320($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -316($fp) + la $a0, data_15 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -316($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -308($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -308($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + lw $a2, -308($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -332($fp) + + # PUSHPARAM + lw $a0, -332($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -324($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -324($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + lw $a2, -324($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -344($fp) + la $a0, data_16 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -344($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -336($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -336($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -340($fp) + lw $a2, -336($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + li $a0, 32 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -360($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -360($fp) + lw $a0 -364($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -360($fp) + la $a0, data_17 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -360($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -352($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -352($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -356($fp) + lw $a2, -352($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -380($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -380($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + lw $a0 -380($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -376($fp) + la $a0, data_18 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -376($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -368($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -368($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + lw $a2, -368($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -384($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -384($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -388($fp) + lw $a2, -384($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -388($fp) + addiu $sp, $sp, 392 + jr $ra + +function_Main_prompt: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_19 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_20 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_Main_get_int: + move $fp, $sp + subu $sp, $sp, 24 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Main_is_even: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -44($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -36($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -64($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -56($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 2 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # - + lw $a0, -80($fp) + lw $a1, -84($fp) + sub $a0, $a0, $a1 + sw $a0, -76($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # - + li $a0 0 + lw $a1, -112($fp) + sub $a0, $a0, $a1 + sw $a0, -116($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -120($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 124 + jr $ra + +function_Main_class_type: + move $fp, $sp + subu $sp, $sp, 108 + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 11 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_6 + + # PUSHPARAM + li $a0, 9 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_7 + + # PUSHPARAM + li $a0, 10 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_8 + + # PUSHPARAM + li $a0, 8 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_9 + + # PUSHPARAM + li $a0, 7 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_10 + + # PUSHPARAM + li $a0, 1 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_11 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_21 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -16($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_7: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_22 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -32($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_23 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -48($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_9: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -68($fp) + la $a0, data_24 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -64($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_25 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_11: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_26 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_12: + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 108 + jr $ra + +function_Main_print: + move $fp, $sp + subu $sp, $sp, 48 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_27 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 48 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 1068 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 16($a1) + +_cil_label_LABEL_13: + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -16($fp) + + # GETATTR + lw $a1 -16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # IF GOTO + lw $a0, -12($fp) + bnez $a0, _cil_label_LABEL_14 + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_14: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -28($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -64($fp) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -64($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_16 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 8 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_29 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 9 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_30 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_17: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -116($fp) + + # PUSHPARAM + lw $a0, -116($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -120($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -120($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + lw $a2, -120($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -124($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -148($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -148($fp) + la $a0, data_31 + sw $a0 16($a1) + + lw $t0 -144($fp) + lw $t1 -148($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -136($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -136($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # IF GOTO + lw $a0, -132($fp) + bnez $a0, _cil_label_LABEL_18 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + lw $a0 -180($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -176($fp) + la $a0, data_32 + sw $a0 16($a1) + + lw $t0 -172($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -164($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -164($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -160($fp) + + # IF GOTO + lw $a0, -160($fp) + bnez $a0, _cil_label_LABEL_20 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -208($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -204($fp) + la $a0, data_33 + sw $a0 16($a1) + + lw $t0 -200($fp) + lw $t1 -204($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -192($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -192($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -196($fp) + lw $a0 12($a1) + sw $a0 -188($fp) + + # IF GOTO + lw $a0, -188($fp) + bnez $a0, _cil_label_LABEL_22 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -228($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_34 + sw $a0 16($a1) + + lw $t0 -228($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -220($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -220($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -224($fp) + lw $a0 12($a1) + sw $a0 -216($fp) + + # IF GOTO + lw $a0, -216($fp) + bnez $a0, _cil_label_LABEL_24 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -256($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + lw $a0 -264($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -260($fp) + la $a0, data_35 + sw $a0 16($a1) + + lw $t0 -256($fp) + lw $t1 -260($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_7 + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 -248($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 -248($fp) +end_equal_7_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + lw $a0 -248($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -252($fp) + lw $a0 12($a1) + sw $a0 -244($fp) + + # IF GOTO + lw $a0, -244($fp) + bnez $a0, _cil_label_LABEL_26 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -284($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_36 + sw $a0 16($a1) + + lw $t0 -284($fp) + lw $t1 -288($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_8 + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -276($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -276($fp) +end_equal_8_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -280($fp) + lw $a0 12($a1) + sw $a0 -272($fp) + + # IF GOTO + lw $a0, -272($fp) + bnez $a0, _cil_label_LABEL_28 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -312($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -320($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -320($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -316($fp) + la $a0, data_37 + sw $a0 16($a1) + + lw $t0 -312($fp) + lw $t1 -316($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_9 + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -304($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -304($fp) +end_equal_9_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -308($fp) + lw $a0 12($a1) + sw $a0 -300($fp) + + # IF GOTO + lw $a0, -300($fp) + bnez $a0, _cil_label_LABEL_30 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -340($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -344($fp) + la $a0, data_38 + sw $a0 16($a1) + + lw $t0 -340($fp) + lw $t1 -344($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_10 + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -332($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -332($fp) +end_equal_10_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + lw $a0 -332($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -336($fp) + lw $a0 12($a1) + sw $a0 -328($fp) + + # IF GOTO + lw $a0, -328($fp) + bnez $a0, _cil_label_LABEL_32 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -368($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -372($fp) + lw $a0 -376($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -372($fp) + la $a0, data_39 + sw $a0 16($a1) + + lw $t0 -368($fp) + lw $t1 -372($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_11 + li $a2 5 + beq $a0 $a2 _eq_int_bool_11 + li $a2 6 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -360($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -360($fp) +end_equal_11_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + lw $a0 -360($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -364($fp) + lw $a0 12($a1) + sw $a0 -356($fp) + + # IF GOTO + lw $a0, -356($fp) + bnez $a0, _cil_label_LABEL_34 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -396($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -404($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -404($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -400($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -400($fp) + lw $a0 -404($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -400($fp) + la $a0, data_40 + sw $a0 16($a1) + + lw $t0 -396($fp) + lw $t1 -400($fp) + beq $t0 $zero _eq_false_12_ + beq $t1 $zero _eq_false_12_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_12 + li $a2 5 + beq $a0 $a2 _eq_int_bool_12 + li $a2 6 + bne $a0 $a2 _not_basic_type_12_ +_eq_str_12_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_12_ + beq $t3 $0 _eq_true_12_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_12_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_12_ + b _eq_true_12_ +_not_basic_type_12_: + bne $t0 $t1 _eq_false_12_ + b _eq_true_12_ +_eq_int_bool_12: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_12_ +_eq_true_12_: + li $a0 1 + sw $a0 -388($fp) + b end_equal_12_ +_eq_false_12_: + li $a0 0 + sw $a0 -388($fp) +end_equal_12_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -392($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -392($fp) + lw $a0 -388($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -392($fp) + lw $a0 12($a1) + sw $a0 -384($fp) + + # IF GOTO + lw $a0, -384($fp) + bnez $a0, _cil_label_LABEL_36 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -408($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -408($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -412($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -424($fp) + + # PUSHPARAM + lw $a0, -424($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -424($fp) + lw $a0 0($a1) + sw $a0 -428($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -428($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -432($fp) + lw $a2, -428($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -432($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -408($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -408($fp) + lw $a0 0($a1) + sw $a0 -416($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -416($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -420($fp) + lw $a2, -416($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -420($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -420($fp) + sw $a0, -380($fp) + + # GOTO + j _cil_label_LABEL_37 + +_cil_label_LABEL_36: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -436($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -436($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -436($fp) + sw $a0 24($a1) + + # ASSIGN + lw $a0, -436($fp) + sw $a0, -380($fp) + +_cil_label_LABEL_37: + # ASSIGN + lw $a0, -380($fp) + sw $a0, -352($fp) + + # GOTO + j _cil_label_LABEL_35 + +_cil_label_LABEL_34: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -440($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -440($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -444($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -440($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -440($fp) + sw $a0, -352($fp) + +_cil_label_LABEL_35: + # ASSIGN + lw $a0, -352($fp) + sw $a0, -324($fp) + + # GOTO + j _cil_label_LABEL_33 + +_cil_label_LABEL_32: + # ALLOCATE + la $v0 type_void + sw $v0 -448($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -452($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -452($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -456($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -468($fp) + + # PUSHPARAM + lw $a0, -468($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -468($fp) + lw $a0 0($a1) + sw $a0 -472($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -472($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -476($fp) + lw $a2, -472($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -476($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -452($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -452($fp) + lw $a0 0($a1) + sw $a0 -460($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -460($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -464($fp) + lw $a2, -460($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -464($fp) + sw $a0, -448($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -496($fp) + + # PUSHPARAM + lw $a0, -496($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -496($fp) + lw $a0 0($a1) + sw $a0 -500($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -500($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -504($fp) + lw $a2, -500($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -448($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -448($fp) + lw $a0 0($a1) + sw $a0 -524($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -524($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -528($fp) + lw $a2, -524($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -532($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -532($fp) + li $a0, 8 + sw $a0 12($a1) + + # GETATTR + lw $a1 -528($fp) + lw $a0 12($a1) + sw $a0 -512($fp) + + # GETATTR + lw $a1 -532($fp) + lw $a0 12($a1) + sw $a0 -516($fp) + + # * + lw $a0, -512($fp) + lw $a1, -516($fp) + mul $a0, $a0, $a1 + sw $a0, -508($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -520($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -520($fp) + lw $a0 -508($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -504($fp) + lw $a0 12($a1) + sw $a0 -484($fp) + + # GETATTR + lw $a1 -520($fp) + lw $a0 12($a1) + sw $a0 -488($fp) + + # - + lw $a0, -484($fp) + lw $a1, -488($fp) + sub $a0, $a0, $a1 + sw $a0, -480($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -492($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -492($fp) + lw $a0 -480($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -548($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -548($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -544($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -544($fp) + lw $a0 -548($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -544($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -544($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -536($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -536($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -540($fp) + lw $a2, -536($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -560($fp) + + # PUSHPARAM + lw $a0, -560($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -552($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -552($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -556($fp) + lw $a2, -552($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -576($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -576($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -572($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -572($fp) + lw $a0 -576($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -572($fp) + la $a0, data_41 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -572($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -564($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -564($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -568($fp) + lw $a2, -564($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -448($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -580($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -580($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -584($fp) + lw $a2, -580($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -600($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -600($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -596($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -596($fp) + lw $a0 -600($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -596($fp) + la $a0, data_42 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -596($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -588($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -588($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -592($fp) + lw $a2, -588($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -604($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -604($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -608($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -492($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -604($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -604($fp) + lw $a0 0($a1) + sw $a0 -620($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -620($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -624($fp) + lw $a2, -620($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -624($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -612($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -612($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -616($fp) + lw $a2, -612($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -640($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -640($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -636($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -636($fp) + lw $a0 -640($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -636($fp) + la $a0, data_19 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -636($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -628($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -628($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -632($fp) + lw $a2, -628($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -448($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -448($fp) + sw $a0, -324($fp) + +_cil_label_LABEL_33: + # ASSIGN + lw $a0, -324($fp) + sw $a0, -296($fp) + + # GOTO + j _cil_label_LABEL_31 + +_cil_label_LABEL_30: + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -652($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -652($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -656($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -668($fp) + + # PUSHPARAM + lw $a0, -668($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -668($fp) + lw $a0 0($a1) + sw $a0 -672($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -672($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -676($fp) + lw $a2, -672($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -676($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -652($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -652($fp) + lw $a0 0($a1) + sw $a0 -660($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -660($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -664($fp) + lw $a2, -660($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -664($fp) + lw $a0 12($a1) + sw $a0 -648($fp) + + # IF GOTO + lw $a0, -648($fp) + bnez $a0, _cil_label_LABEL_38 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -692($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -692($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -688($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -688($fp) + lw $a0 -692($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -688($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -688($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -680($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -680($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -684($fp) + lw $a2, -680($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -704($fp) + + # PUSHPARAM + lw $a0, -704($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -696($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -696($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -700($fp) + lw $a2, -696($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -720($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -720($fp) + li $a0, 23 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -716($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -716($fp) + lw $a0 -720($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -716($fp) + la $a0, data_43 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -716($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -708($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -708($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -712($fp) + lw $a2, -708($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -712($fp) + sw $a0, -644($fp) + + # GOTO + j _cil_label_LABEL_39 + +_cil_label_LABEL_38: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -736($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -736($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -732($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -732($fp) + lw $a0 -736($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -732($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -732($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -724($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -724($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -728($fp) + lw $a2, -724($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -748($fp) + + # PUSHPARAM + lw $a0, -748($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -740($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -740($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -744($fp) + lw $a2, -740($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -764($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -764($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -760($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -760($fp) + lw $a0 -764($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -760($fp) + la $a0, data_44 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -760($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -752($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -752($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -756($fp) + lw $a2, -752($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -756($fp) + sw $a0, -644($fp) + +_cil_label_LABEL_39: + # ASSIGN + lw $a0, -644($fp) + sw $a0, -296($fp) + +_cil_label_LABEL_31: + # ASSIGN + lw $a0, -296($fp) + sw $a0, -268($fp) + + # GOTO + j _cil_label_LABEL_29 + +_cil_label_LABEL_28: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -768($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -768($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -772($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -780($fp) + + # PUSHPARAM + lw $a0, -780($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -780($fp) + lw $a0 0($a1) + sw $a0 -784($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -784($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -788($fp) + lw $a2, -784($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -788($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -768($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 9 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -776($fp) + li $a2, 9 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -776($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -776($fp) + sw $a0, -268($fp) + +_cil_label_LABEL_29: + # ASSIGN + lw $a0, -268($fp) + sw $a0, -240($fp) + + # GOTO + j _cil_label_LABEL_27 + +_cil_label_LABEL_26: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -792($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -792($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -796($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -804($fp) + + # PUSHPARAM + lw $a0, -804($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -804($fp) + lw $a0 0($a1) + sw $a0 -808($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -808($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -812($fp) + lw $a2, -808($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -812($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -792($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 8 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -800($fp) + li $a2, 8 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -800($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -800($fp) + sw $a0, -240($fp) + +_cil_label_LABEL_27: + # ASSIGN + lw $a0, -240($fp) + sw $a0, -212($fp) + + # GOTO + j _cil_label_LABEL_25 + +_cil_label_LABEL_24: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -816($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -816($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -820($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -828($fp) + + # PUSHPARAM + lw $a0, -828($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -828($fp) + lw $a0 0($a1) + sw $a0 -832($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -832($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -836($fp) + lw $a2, -832($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -836($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -816($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 7 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -824($fp) + li $a2, 7 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -824($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -824($fp) + sw $a0, -212($fp) + +_cil_label_LABEL_25: + # ASSIGN + lw $a0, -212($fp) + sw $a0, -184($fp) + + # GOTO + j _cil_label_LABEL_23 + +_cil_label_LABEL_22: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -840($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -840($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -844($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -856($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -856($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -860($fp) + lw $a2, -856($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -860($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -840($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -840($fp) + lw $a0 0($a1) + sw $a0 -848($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -848($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -852($fp) + lw $a2, -848($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -852($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -864($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -864($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -868($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -880($fp) + + # PUSHPARAM + lw $a0, -880($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -880($fp) + lw $a0 0($a1) + sw $a0 -884($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -884($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -888($fp) + lw $a2, -884($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -888($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -892($fp) + + # PUSHPARAM + lw $a0, -892($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -892($fp) + lw $a0 0($a1) + sw $a0 -896($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -896($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -900($fp) + lw $a2, -896($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -900($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -864($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -864($fp) + lw $a0 0($a1) + sw $a0 -872($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -872($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -876($fp) + lw $a2, -872($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -876($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -876($fp) + sw $a0, -184($fp) + +_cil_label_LABEL_23: + # ASSIGN + lw $a0, -184($fp) + sw $a0, -156($fp) + + # GOTO + j _cil_label_LABEL_21 + +_cil_label_LABEL_20: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -916($fp) + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -908($fp) + + # PUSHPARAM + li $a0, 9 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_40 + + # PUSHPARAM + li $a0, 7 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_41 + + # PUSHPARAM + li $a0, 1 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_42 + +_cil_label_LABEL_40: + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -928($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -928($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -932($fp) + lw $a2, -928($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -932($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -920($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -920($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -924($fp) + lw $a2, -920($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -924($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -924($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_41: + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -944($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -944($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -948($fp) + lw $a2, -944($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -948($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -936($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -936($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -940($fp) + lw $a2, -936($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -940($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -940($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_42: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -964($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -964($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -960($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -960($fp) + lw $a0 -964($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -960($fp) + la $a0, data_26 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -960($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -952($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -952($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -956($fp) + lw $a2, -952($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -968($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -968($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -972($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -988($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -988($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -984($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -984($fp) + lw $a0 -988($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -984($fp) + la $a0, data_45 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -984($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -968($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -968($fp) + lw $a0 0($a1) + sw $a0 -976($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -976($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -980($fp) + lw $a2, -976($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -992($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -992($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -996($fp) + lw $a2, -992($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1000($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -1000($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -1000($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_43: + # ASSIGN + lw $a0, -912($fp) + sw $a0, -156($fp) + +_cil_label_LABEL_21: + # ASSIGN + lw $a0, -156($fp) + sw $a0, -128($fp) + + # GOTO + j _cil_label_LABEL_19 + +_cil_label_LABEL_18: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1004($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -1004($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1008($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -1020($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1020($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1024($fp) + lw $a2, -1020($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1024($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -1004($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1004($fp) + lw $a0 0($a1) + sw $a0 -1012($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1012($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1016($fp) + lw $a2, -1012($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -1016($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1028($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -1028($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1032($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -1044($fp) + + # PUSHPARAM + lw $a0, -1044($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1044($fp) + lw $a0 0($a1) + sw $a0 -1048($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1048($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1052($fp) + lw $a2, -1048($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1052($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -1056($fp) + + # PUSHPARAM + lw $a0, -1056($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1056($fp) + lw $a0 0($a1) + sw $a0 -1060($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1060($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1064($fp) + lw $a2, -1060($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1064($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -1028($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1028($fp) + lw $a0 0($a1) + sw $a0 -1036($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1036($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1040($fp) + lw $a2, -1036($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -1040($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -1040($fp) + sw $a0, -128($fp) + +_cil_label_LABEL_19: + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_15: + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 1068 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A_set_var: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A_method1: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A_method2: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # + + lw $a0, -8($fp) + lw $a1, -12($fp) + add $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_A_method3: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # - + li $a0 0 + lw $a1, -4($fp) + sub $a0, $a0, $a1 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -12($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_A_method4: + move $fp, $sp + subu $sp, $sp, 96 + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_44 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # - + lw $a0, -32($fp) + lw $a1, -36($fp) + sub $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -40($fp) + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -56($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_45 + +_cil_label_LABEL_44: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -60($fp) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -80($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -92($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_45: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 96 + jr $ra + +function_A_method5: + move $fp, $sp + subu $sp, $sp, 84 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 1 + sw $a0 12($a1) + +_cil_label_LABEL_46: + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # <= + lw $a1, -20($fp) + lw $a2, -24($fp) + sle $a0, $a1, $a2 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -28($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # IF GOTO + lw $a0, -12($fp) + bnez $a0, _cil_label_LABEL_47 + + # GOTO + j _cil_label_LABEL_48 + +_cil_label_LABEL_47: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # * + lw $a0, -36($fp) + lw $a1, -40($fp) + mul $a0, $a0, $a1 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -44($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # + + lw $a0, -52($fp) + lw $a1, -56($fp) + add $a0, $a0, $a1 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -4($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_48: + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -68($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 84 + jr $ra + +function_B__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_B_method5: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # * + lw $a0, -8($fp) + lw $a1, -12($fp) + mul $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_C__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_C_method6: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # - + li $a0 0 + lw $a1, -4($fp) + sub $a0, $a0, $a1 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -12($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_C_method5: + move $fp, $sp + subu $sp, $sp, 52 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # * + lw $a0, -24($fp) + lw $a1, -28($fp) + mul $a0, $a0, $a1 + sw $a0, -20($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # * + lw $a0, -8($fp) + lw $a1, -12($fp) + mul $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -48($fp) + addiu $sp, $sp, 52 + jr $ra + +function_D__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_D_method7: + move $fp, $sp + subu $sp, $sp, 148 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_49 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -44($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_13 + li $a2 5 + beq $a0 $a2 _eq_int_bool_13 + li $a2 6 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -36($fp) +end_equal_13_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_51 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -64($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_14_ + beq $t1 $zero _eq_false_14_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_14 + li $a2 5 + beq $a0 $a2 _eq_int_bool_14 + li $a2 6 + bne $a0 $a2 _not_basic_type_14_ +_eq_str_14_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_14_ + beq $t3 $0 _eq_true_14_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_14_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_14_ + b _eq_true_14_ +_not_basic_type_14_: + bne $t0 $t1 _eq_false_14_ + b _eq_true_14_ +_eq_int_bool_14: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_14_ +_eq_true_14_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_14_ +_eq_false_14_: + li $a0 0 + sw $a0 -56($fp) +end_equal_14_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_53 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 -84($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_15 + li $a2 5 + beq $a0 $a2 _eq_int_bool_15 + li $a2 6 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -76($fp) +end_equal_15_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_55 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 3 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # - + lw $a0, -100($fp) + lw $a1, -104($fp) + sub $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -92($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_56 + +_cil_label_LABEL_55: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -116($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_56: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_54 + +_cil_label_LABEL_53: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_54: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_52 + +_cil_label_LABEL_51: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -124($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_52: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_50 + +_cil_label_LABEL_49: + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # - + li $a0 0 + lw $a1, -136($fp) + sub $a0, $a0, $a1 + sw $a0, -140($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -132($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_50: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 148 + jr $ra + +function_E__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_E_method6: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 8 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # / + lw $a0, -8($fp) + lw $a1, -12($fp) + beqz $a1 _div_error_16_ + div $a0, $a0, $a1 + sw $a0, -4($fp) + b _div_end_16_ +_div_error_16_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_16_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_A2I__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A2I_c2i: + move $fp, $sp + subu $sp, $sp, 316 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_46 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_17 + li $a2 5 + beq $a0 $a2 _eq_int_bool_17 + li $a2 6 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -8($fp) +end_equal_17_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_57 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_47 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_18_ + beq $t1 $zero _eq_false_18_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_18 + li $a2 5 + beq $a0 $a2 _eq_int_bool_18 + li $a2 6 + bne $a0 $a2 _not_basic_type_18_ +_eq_str_18_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_18_ + beq $t3 $0 _eq_true_18_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_18_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_18_ + b _eq_true_18_ +_not_basic_type_18_: + bne $t0 $t1 _eq_false_18_ + b _eq_true_18_ +_eq_int_bool_18: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_18_ +_eq_true_18_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_18_ +_eq_false_18_: + li $a0 0 + sw $a0 -32($fp) +end_equal_18_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_59 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_48 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_19 + li $a2 5 + beq $a0 $a2 _eq_int_bool_19 + li $a2 6 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -56($fp) +end_equal_19_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_61 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_49 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_20_ + beq $t1 $zero _eq_false_20_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_20 + li $a2 5 + beq $a0 $a2 _eq_int_bool_20 + li $a2 6 + bne $a0 $a2 _not_basic_type_20_ +_eq_str_20_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_20_ + beq $t3 $0 _eq_true_20_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_20_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_20_ + b _eq_true_20_ +_not_basic_type_20_: + bne $t0 $t1 _eq_false_20_ + b _eq_true_20_ +_eq_int_bool_20: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_20_ +_eq_true_20_: + li $a0 1 + sw $a0 -80($fp) + b end_equal_20_ +_eq_false_20_: + li $a0 0 + sw $a0 -80($fp) +end_equal_20_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_63 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_50 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_21_ + beq $t1 $zero _eq_false_21_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_21 + li $a2 5 + beq $a0 $a2 _eq_int_bool_21 + li $a2 6 + bne $a0 $a2 _not_basic_type_21_ +_eq_str_21_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_21_ + beq $t3 $0 _eq_true_21_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_21_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_21_ + b _eq_true_21_ +_not_basic_type_21_: + bne $t0 $t1 _eq_false_21_ + b _eq_true_21_ +_eq_int_bool_21: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_21_ +_eq_true_21_: + li $a0 1 + sw $a0 -104($fp) + b end_equal_21_ +_eq_false_21_: + li $a0 0 + sw $a0 -104($fp) +end_equal_21_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_65 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_51 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_22_ + beq $t1 $zero _eq_false_22_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_22 + li $a2 5 + beq $a0 $a2 _eq_int_bool_22 + li $a2 6 + bne $a0 $a2 _not_basic_type_22_ +_eq_str_22_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_22_ + beq $t3 $0 _eq_true_22_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_22_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_22_ + b _eq_true_22_ +_not_basic_type_22_: + bne $t0 $t1 _eq_false_22_ + b _eq_true_22_ +_eq_int_bool_22: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_22_ +_eq_true_22_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_22_ +_eq_false_22_: + li $a0 0 + sw $a0 -128($fp) +end_equal_22_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_67 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -160($fp) + la $a0, data_52 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -160($fp) + beq $t0 $zero _eq_false_23_ + beq $t1 $zero _eq_false_23_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_23 + li $a2 5 + beq $a0 $a2 _eq_int_bool_23 + li $a2 6 + bne $a0 $a2 _not_basic_type_23_ +_eq_str_23_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_23_ + beq $t3 $0 _eq_true_23_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_23_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_23_ + b _eq_true_23_ +_not_basic_type_23_: + bne $t0 $t1 _eq_false_23_ + b _eq_true_23_ +_eq_int_bool_23: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_23_ +_eq_true_23_: + li $a0 1 + sw $a0 -152($fp) + b end_equal_23_ +_eq_false_23_: + li $a0 0 + sw $a0 -152($fp) +end_equal_23_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -148($fp) + + # IF GOTO + lw $a0, -148($fp) + bnez $a0, _cil_label_LABEL_69 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_53 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -184($fp) + beq $t0 $zero _eq_false_24_ + beq $t1 $zero _eq_false_24_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_24 + li $a2 5 + beq $a0 $a2 _eq_int_bool_24 + li $a2 6 + bne $a0 $a2 _not_basic_type_24_ +_eq_str_24_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_24_ + beq $t3 $0 _eq_true_24_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_24_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_24_ + b _eq_true_24_ +_not_basic_type_24_: + bne $t0 $t1 _eq_false_24_ + b _eq_true_24_ +_eq_int_bool_24: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_24_ +_eq_true_24_: + li $a0 1 + sw $a0 -176($fp) + b end_equal_24_ +_eq_false_24_: + li $a0 0 + sw $a0 -176($fp) +end_equal_24_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # IF GOTO + lw $a0, -172($fp) + bnez $a0, _cil_label_LABEL_71 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_54 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -208($fp) + beq $t0 $zero _eq_false_25_ + beq $t1 $zero _eq_false_25_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_25 + li $a2 5 + beq $a0 $a2 _eq_int_bool_25 + li $a2 6 + bne $a0 $a2 _not_basic_type_25_ +_eq_str_25_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_25_ + beq $t3 $0 _eq_true_25_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_25_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_25_ + b _eq_true_25_ +_not_basic_type_25_: + bne $t0 $t1 _eq_false_25_ + b _eq_true_25_ +_eq_int_bool_25: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_25_ +_eq_true_25_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_25_ +_eq_false_25_: + li $a0 0 + sw $a0 -200($fp) +end_equal_25_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_73 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_55 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_26_ + beq $t1 $zero _eq_false_26_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_26 + li $a2 5 + beq $a0 $a2 _eq_int_bool_26 + li $a2 6 + bne $a0 $a2 _not_basic_type_26_ +_eq_str_26_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_26_ + beq $t3 $0 _eq_true_26_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_26_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_26_ + b _eq_true_26_ +_not_basic_type_26_: + bne $t0 $t1 _eq_false_26_ + b _eq_true_26_ +_eq_int_bool_26: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_26_ +_eq_true_26_: + li $a0 1 + sw $a0 -224($fp) + b end_equal_26_ +_eq_false_26_: + li $a0 0 + sw $a0 -224($fp) +end_equal_26_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -228($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # IF GOTO + lw $a0, -220($fp) + bnez $a0, _cil_label_LABEL_75 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_56 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -256($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -240($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -264($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -264($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + lw $a2, -264($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -216($fp) + + # GOTO + j _cil_label_LABEL_76 + +_cil_label_LABEL_75: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 9 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -276($fp) + sw $a0, -216($fp) + +_cil_label_LABEL_76: + # ASSIGN + lw $a0, -216($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_74 + +_cil_label_LABEL_73: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + li $a0, 8 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_74: + # ASSIGN + lw $a0, -192($fp) + sw $a0, -168($fp) + + # GOTO + j _cil_label_LABEL_72 + +_cil_label_LABEL_71: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 7 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -284($fp) + sw $a0, -168($fp) + +_cil_label_LABEL_72: + # ASSIGN + lw $a0, -168($fp) + sw $a0, -144($fp) + + # GOTO + j _cil_label_LABEL_70 + +_cil_label_LABEL_69: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 6 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, -144($fp) + +_cil_label_LABEL_70: + # ASSIGN + lw $a0, -144($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_68 + +_cil_label_LABEL_67: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 5 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -292($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_68: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -96($fp) + + # GOTO + j _cil_label_LABEL_66 + +_cil_label_LABEL_65: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + li $a0, 4 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -296($fp) + sw $a0, -96($fp) + +_cil_label_LABEL_66: + # ASSIGN + lw $a0, -96($fp) + sw $a0, -72($fp) + + # GOTO + j _cil_label_LABEL_64 + +_cil_label_LABEL_63: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 3 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -300($fp) + sw $a0, -72($fp) + +_cil_label_LABEL_64: + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_62 + +_cil_label_LABEL_61: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 2 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_62: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_60 + +_cil_label_LABEL_59: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -308($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_60: + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_58 + +_cil_label_LABEL_57: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -312($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -312($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_58: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 316 + jr $ra + +function_A2I_i2c: + move $fp, $sp + subu $sp, $sp, 320 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_27_ + beq $t1 $zero _eq_false_27_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_27 + li $a2 5 + beq $a0 $a2 _eq_int_bool_27 + li $a2 6 + bne $a0 $a2 _not_basic_type_27_ +_eq_str_27_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_27_ + beq $t3 $0 _eq_true_27_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_27_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_27_ + b _eq_true_27_ +_not_basic_type_27_: + bne $t0 $t1 _eq_false_27_ + b _eq_true_27_ +_eq_int_bool_27: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_27_ +_eq_true_27_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_27_ +_eq_false_27_: + li $a0 0 + sw $a0 -8($fp) +end_equal_27_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_77 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -36($fp) + beq $t0 $zero _eq_false_28_ + beq $t1 $zero _eq_false_28_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_28 + li $a2 5 + beq $a0 $a2 _eq_int_bool_28 + li $a2 6 + bne $a0 $a2 _not_basic_type_28_ +_eq_str_28_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_28_ + beq $t3 $0 _eq_true_28_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_28_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_28_ + b _eq_true_28_ +_not_basic_type_28_: + bne $t0 $t1 _eq_false_28_ + b _eq_true_28_ +_eq_int_bool_28: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_28_ +_eq_true_28_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_28_ +_eq_false_28_: + li $a0 0 + sw $a0 -28($fp) +end_equal_28_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_79 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_29_ + beq $t1 $zero _eq_false_29_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_29 + li $a2 5 + beq $a0 $a2 _eq_int_bool_29 + li $a2 6 + bne $a0 $a2 _not_basic_type_29_ +_eq_str_29_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_29_ + beq $t3 $0 _eq_true_29_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_29_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_29_ + b _eq_true_29_ +_not_basic_type_29_: + bne $t0 $t1 _eq_false_29_ + b _eq_true_29_ +_eq_int_bool_29: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_29_ +_eq_true_29_: + li $a0 1 + sw $a0 -48($fp) + b end_equal_29_ +_eq_false_29_: + li $a0 0 + sw $a0 -48($fp) +end_equal_29_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_81 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_30_ + beq $t1 $zero _eq_false_30_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_30 + li $a2 5 + beq $a0 $a2 _eq_int_bool_30 + li $a2 6 + bne $a0 $a2 _not_basic_type_30_ +_eq_str_30_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_30_ + beq $t3 $0 _eq_true_30_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_30_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_30_ + b _eq_true_30_ +_not_basic_type_30_: + bne $t0 $t1 _eq_false_30_ + b _eq_true_30_ +_eq_int_bool_30: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_30_ +_eq_true_30_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_30_ +_eq_false_30_: + li $a0 0 + sw $a0 -68($fp) +end_equal_30_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_83 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 4 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -96($fp) + beq $t0 $zero _eq_false_31_ + beq $t1 $zero _eq_false_31_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_31 + li $a2 5 + beq $a0 $a2 _eq_int_bool_31 + li $a2 6 + bne $a0 $a2 _not_basic_type_31_ +_eq_str_31_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_31_ + beq $t3 $0 _eq_true_31_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_31_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_31_ + b _eq_true_31_ +_not_basic_type_31_: + bne $t0 $t1 _eq_false_31_ + b _eq_true_31_ +_eq_int_bool_31: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_31_ +_eq_true_31_: + li $a0 1 + sw $a0 -88($fp) + b end_equal_31_ +_eq_false_31_: + li $a0 0 + sw $a0 -88($fp) +end_equal_31_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_85 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 5 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -116($fp) + beq $t0 $zero _eq_false_32_ + beq $t1 $zero _eq_false_32_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_32 + li $a2 5 + beq $a0 $a2 _eq_int_bool_32 + li $a2 6 + bne $a0 $a2 _not_basic_type_32_ +_eq_str_32_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_32_ + beq $t3 $0 _eq_true_32_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_32_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_32_ + b _eq_true_32_ +_not_basic_type_32_: + bne $t0 $t1 _eq_false_32_ + b _eq_true_32_ +_eq_int_bool_32: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_32_ +_eq_true_32_: + li $a0 1 + sw $a0 -108($fp) + b end_equal_32_ +_eq_false_32_: + li $a0 0 + sw $a0 -108($fp) +end_equal_32_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # IF GOTO + lw $a0, -104($fp) + bnez $a0, _cil_label_LABEL_87 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 6 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_33_ + beq $t1 $zero _eq_false_33_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_33 + li $a2 5 + beq $a0 $a2 _eq_int_bool_33 + li $a2 6 + bne $a0 $a2 _not_basic_type_33_ +_eq_str_33_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_33_ + beq $t3 $0 _eq_true_33_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_33_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_33_ + b _eq_true_33_ +_not_basic_type_33_: + bne $t0 $t1 _eq_false_33_ + b _eq_true_33_ +_eq_int_bool_33: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_33_ +_eq_true_33_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_33_ +_eq_false_33_: + li $a0 0 + sw $a0 -128($fp) +end_equal_33_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_89 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 7 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -156($fp) + beq $t0 $zero _eq_false_34_ + beq $t1 $zero _eq_false_34_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_34 + li $a2 5 + beq $a0 $a2 _eq_int_bool_34 + li $a2 6 + bne $a0 $a2 _not_basic_type_34_ +_eq_str_34_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_34_ + beq $t3 $0 _eq_true_34_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_34_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_34_ + b _eq_true_34_ +_not_basic_type_34_: + bne $t0 $t1 _eq_false_34_ + b _eq_true_34_ +_eq_int_bool_34: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_34_ +_eq_true_34_: + li $a0 1 + sw $a0 -148($fp) + b end_equal_34_ +_eq_false_34_: + li $a0 0 + sw $a0 -148($fp) +end_equal_34_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # IF GOTO + lw $a0, -144($fp) + bnez $a0, _cil_label_LABEL_91 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 8 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_35_ + beq $t1 $zero _eq_false_35_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_35 + li $a2 5 + beq $a0 $a2 _eq_int_bool_35 + li $a2 6 + bne $a0 $a2 _not_basic_type_35_ +_eq_str_35_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_35_ + beq $t3 $0 _eq_true_35_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_35_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_35_ + b _eq_true_35_ +_not_basic_type_35_: + bne $t0 $t1 _eq_false_35_ + b _eq_true_35_ +_eq_int_bool_35: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_35_ +_eq_true_35_: + li $a0 1 + sw $a0 -168($fp) + b end_equal_35_ +_eq_false_35_: + li $a0 0 + sw $a0 -168($fp) +end_equal_35_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # IF GOTO + lw $a0, -164($fp) + bnez $a0, _cil_label_LABEL_93 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + li $a0, 9 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -196($fp) + beq $t0 $zero _eq_false_36_ + beq $t1 $zero _eq_false_36_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_36 + li $a2 5 + beq $a0 $a2 _eq_int_bool_36 + li $a2 6 + bne $a0 $a2 _not_basic_type_36_ +_eq_str_36_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_36_ + beq $t3 $0 _eq_true_36_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_36_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_36_ + b _eq_true_36_ +_not_basic_type_36_: + bne $t0 $t1 _eq_false_36_ + b _eq_true_36_ +_eq_int_bool_36: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_36_ +_eq_true_36_: + li $a0 1 + sw $a0 -188($fp) + b end_equal_36_ +_eq_false_36_: + li $a0 0 + sw $a0 -188($fp) +end_equal_36_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -192($fp) + lw $a0 12($a1) + sw $a0 -184($fp) + + # IF GOTO + lw $a0, -184($fp) + bnez $a0, _cil_label_LABEL_95 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -216($fp) + la $a0, data_56 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -216($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -200($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -224($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -224($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + lw $a2, -224($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -232($fp) + sw $a0, -180($fp) + + # GOTO + j _cil_label_LABEL_96 + +_cil_label_LABEL_95: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -244($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -240($fp) + la $a0, data_55 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -240($fp) + sw $a0, -180($fp) + +_cil_label_LABEL_96: + # ASSIGN + lw $a0, -180($fp) + sw $a0, -160($fp) + + # GOTO + j _cil_label_LABEL_94 + +_cil_label_LABEL_93: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + lw $a0 -252($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -248($fp) + la $a0, data_54 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -160($fp) + +_cil_label_LABEL_94: + # ASSIGN + lw $a0, -160($fp) + sw $a0, -140($fp) + + # GOTO + j _cil_label_LABEL_92 + +_cil_label_LABEL_91: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_53 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -140($fp) + +_cil_label_LABEL_92: + # ASSIGN + lw $a0, -140($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_90 + +_cil_label_LABEL_89: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + lw $a0 -268($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -264($fp) + la $a0, data_52 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_90: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -100($fp) + + # GOTO + j _cil_label_LABEL_88 + +_cil_label_LABEL_87: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_51 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -100($fp) + +_cil_label_LABEL_88: + # ASSIGN + lw $a0, -100($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_86 + +_cil_label_LABEL_85: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -284($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -280($fp) + la $a0, data_50 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_86: + # ASSIGN + lw $a0, -80($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_84 + +_cil_label_LABEL_83: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_49 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_84: + # ASSIGN + lw $a0, -60($fp) + sw $a0, -40($fp) + + # GOTO + j _cil_label_LABEL_82 + +_cil_label_LABEL_81: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + lw $a0 -300($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -296($fp) + la $a0, data_48 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -296($fp) + sw $a0, -40($fp) + +_cil_label_LABEL_82: + # ASSIGN + lw $a0, -40($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_80 + +_cil_label_LABEL_79: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + lw $a0 -308($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -304($fp) + la $a0, data_47 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_80: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_78 + +_cil_label_LABEL_77: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -312($fp) + lw $a0 -316($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -312($fp) + la $a0, data_46 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -312($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_78: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 320 + jr $ra + +function_A2I_a2i: + move $fp, $sp + subu $sp, $sp, 228 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_37_ + beq $t1 $zero _eq_false_37_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_37 + li $a2 5 + beq $a0 $a2 _eq_int_bool_37 + li $a2 6 + bne $a0 $a2 _not_basic_type_37_ +_eq_str_37_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_37_ + beq $t3 $0 _eq_true_37_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_37_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_37_ + b _eq_true_37_ +_not_basic_type_37_: + bne $t0 $t1 _eq_false_37_ + b _eq_true_37_ +_eq_int_bool_37: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_37_ +_eq_true_37_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_37_ +_eq_false_37_: + li $a0 0 + sw $a0 -8($fp) +end_equal_37_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_97 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_57 + sw $a0 16($a1) + + lw $t0 -48($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_38_ + beq $t1 $zero _eq_false_38_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_38 + li $a2 5 + beq $a0 $a2 _eq_int_bool_38 + li $a2 6 + bne $a0 $a2 _not_basic_type_38_ +_eq_str_38_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_38_ + beq $t3 $0 _eq_true_38_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_38_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_38_ + b _eq_true_38_ +_not_basic_type_38_: + bne $t0 $t1 _eq_false_38_ + b _eq_true_38_ +_eq_int_bool_38: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_38_ +_eq_true_38_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_38_ +_eq_false_38_: + li $a0 0 + sw $a0 -36($fp) +end_equal_38_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_99 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_58 + sw $a0 16($a1) + + lw $t0 -88($fp) + lw $t1 -100($fp) + beq $t0 $zero _eq_false_39_ + beq $t1 $zero _eq_false_39_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_39 + li $a2 5 + beq $a0 $a2 _eq_int_bool_39 + li $a2 6 + bne $a0 $a2 _not_basic_type_39_ +_eq_str_39_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_39_ + beq $t3 $0 _eq_true_39_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_39_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_39_ + b _eq_true_39_ +_not_basic_type_39_: + bne $t0 $t1 _eq_false_39_ + b _eq_true_39_ +_eq_int_bool_39: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_39_ +_eq_true_39_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_39_ +_eq_false_39_: + li $a0 0 + sw $a0 -76($fp) +end_equal_39_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_101 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_102 + +_cil_label_LABEL_101: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -140($fp) + + # - + lw $a0, -136($fp) + lw $a1, -140($fp) + sub $a0, $a0, $a1 + sw $a0, -132($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -132($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -128($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_102: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_100 + +_cil_label_LABEL_99: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -212($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # GETATTR + lw $a1 -216($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # - + lw $a0, -196($fp) + lw $a1, -200($fp) + sub $a0, $a0, $a1 + sw $a0, -192($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -184($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -184($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + lw $a2, -184($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # - + li $a0 0 + lw $a1, -164($fp) + sub $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_100: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_98 + +_cil_label_LABEL_97: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_98: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 228 + jr $ra + +function_A2I_a2i_aux: + move $fp, $sp + subu $sp, $sp, 116 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_103: + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_104 + + # GOTO + j _cil_label_LABEL_105 + +_cil_label_LABEL_104: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # * + lw $a0, -60($fp) + lw $a1, -64($fp) + mul $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # + + lw $a0, -44($fp) + lw $a1, -48($fp) + add $a0, $a0, $a1 + sw $a0, -40($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_103 + +_cil_label_LABEL_105: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 116 + jr $ra + +function_A2I_i2a: + move $fp, $sp + subu $sp, $sp, 120 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_40_ + beq $t1 $zero _eq_false_40_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_40 + li $a2 5 + beq $a0 $a2 _eq_int_bool_40 + li $a2 6 + bne $a0 $a2 _not_basic_type_40_ +_eq_str_40_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_40_ + beq $t3 $0 _eq_true_40_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_40_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_40_ + b _eq_true_40_ +_not_basic_type_40_: + bne $t0 $t1 _eq_false_40_ + b _eq_true_40_ +_eq_int_bool_40: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_40_ +_eq_true_40_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_40_ +_eq_false_40_: + li $a0 0 + sw $a0 -8($fp) +end_equal_40_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_106 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # < + lw $a1, -32($fp) + lw $a2, -36($fp) + slt $a0, $a1, $a2 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_108 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_57 + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # - + li $a0 0 + lw $a1, -88($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # * + lw $a0, -76($fp) + lw $a1, -80($fp) + mul $a0, $a0, $a1 + sw $a0, -72($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_109 + +_cil_label_LABEL_108: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_109: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_107 + +_cil_label_LABEL_106: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_46 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_107: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_A2I_i2a_aux: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_41_ + beq $t1 $zero _eq_false_41_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_41 + li $a2 5 + beq $a0 $a2 _eq_int_bool_41 + li $a2 6 + bne $a0 $a2 _not_basic_type_41_ +_eq_str_41_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_41_ + beq $t3 $0 _eq_true_41_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_41_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_41_ + b _eq_true_41_ +_not_basic_type_41_: + bne $t0 $t1 _eq_false_41_ + b _eq_true_41_ +_eq_int_bool_41: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_41_ +_eq_true_41_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_41_ +_eq_false_41_: + li $a0 0 + sw $a0 -8($fp) +end_equal_41_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_110 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # / + lw $a0, -24($fp) + lw $a1, -28($fp) + beqz $a1 _div_error_42_ + div $a0, $a0, $a1 + sw $a0, -20($fp) + b _div_end_42_ +_div_error_42_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_42_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # * + lw $a0, -84($fp) + lw $a1, -88($fp) + mul $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_111 + +_cil_label_LABEL_110: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_111: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/arith.s b/tests/codegen/arith.s new file mode 100644 index 00000000..1e22c4c7 --- /dev/null +++ b/tests/codegen/arith.s @@ -0,0 +1,18736 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n\tTo add a number to " + data_2: .align 2 + .asciiz "...enter a:\n" + data_3: .align 2 + .asciiz "\tTo negate " + data_4: .align 2 + .asciiz "...enter b:\n" + data_5: .align 2 + .asciiz "\tTo find the difference between " + data_6: .align 2 + .asciiz "and another number...enter c:\n" + data_7: .align 2 + .asciiz "\tTo find the factorial of " + data_8: .align 2 + .asciiz "...enter d:\n" + data_9: .align 2 + .asciiz "\tTo square " + data_10: .align 2 + .asciiz "...enter e:\n" + data_11: .align 2 + .asciiz "\tTo cube " + data_12: .align 2 + .asciiz "...enter f:\n" + data_13: .align 2 + .asciiz "\tTo find out if " + data_14: .align 2 + .asciiz "is a multiple of 3...enter g:\n" + data_15: .align 2 + .asciiz "\tTo divide " + data_16: .align 2 + .asciiz "by 8...enter h:\n" + data_17: .align 2 + .asciiz "\tTo get a new number...enter j:\n" + data_18: .align 2 + .asciiz "\tTo quit...enter q:\n\n" + data_19: .align 2 + .asciiz "\n" + data_20: .align 2 + .asciiz "Please enter a number... " + data_21: .align 2 + .asciiz "Class type is now E\n" + data_22: .align 2 + .asciiz "Class type is now C\n" + data_23: .align 2 + .asciiz "Class type is now D\n" + data_24: .align 2 + .asciiz "Class type is now B\n" + data_25: .align 2 + .asciiz "Class type is now A\n" + data_26: .align 2 + .asciiz "Oooops\n" + data_27: .align 2 + .asciiz " " + data_28: .align 2 + .asciiz "number " + data_29: .align 2 + .asciiz "is odd!\n" + data_30: .align 2 + .asciiz "is even!\n" + data_31: .align 2 + .asciiz "a" + data_32: .align 2 + .asciiz "b" + data_33: .align 2 + .asciiz "c" + data_34: .align 2 + .asciiz "d" + data_35: .align 2 + .asciiz "e" + data_36: .align 2 + .asciiz "f" + data_37: .align 2 + .asciiz "g" + data_38: .align 2 + .asciiz "h" + data_39: .align 2 + .asciiz "j" + data_40: .align 2 + .asciiz "q" + data_41: .align 2 + .asciiz "is equal to " + data_42: .align 2 + .asciiz "times 8 with a remainder of " + data_43: .align 2 + .asciiz "is not divisible by 3.\n" + data_44: .align 2 + .asciiz "is divisible by 3.\n" + data_45: .align 2 + .asciiz "0" + data_46: .align 2 + .asciiz "1" + data_47: .align 2 + .asciiz "2" + data_48: .align 2 + .asciiz "3" + data_49: .align 2 + .asciiz "4" + data_50: .align 2 + .asciiz "5" + data_51: .align 2 + .asciiz "6" + data_52: .align 2 + .asciiz "7" + data_53: .align 2 + .asciiz "8" + data_54: .align 2 + .asciiz "9" + data_55: .align 2 + .asciiz "-" + data_56: .align 2 + .asciiz "+" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_A: .align 2 + .asciiz "A" + classname_B: .align 2 + .asciiz "B" + classname_C: .align 2 + .asciiz "C" + classname_D: .align 2 + .asciiz "D" + classname_E: .align 2 + .asciiz "E" + classname_A2I: .align 2 + .asciiz "A2I" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 52 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_A + sw $t1 28($s1) + la $t1 classname_B + sw $t1 32($s1) + la $t1 classname_C + sw $t1 36($s1) + la $t1 classname_D + sw $t1 40($s1) + la $t1 classname_E + sw $t1 44($s1) + la $t1 classname_A2I + sw $t1 48($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 104 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 28 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 28 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type A + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type B + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type C + li $a0 16 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type D + li $a0 16 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 80($s0) + + # Type E + li $a0 16 + li $v0 9 + syscall + li $a0 11 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 88($s0) + + # Type A2I + li $a0 12 + li $v0 9 + syscall + li $a0 12 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 96($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 56 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_menu + sw $t1 28($v0) + la $t1 function_Main_prompt + sw $t1 32($v0) + la $t1 function_Main_get_int + sw $t1 36($v0) + la $t1 function_Main_is_even + sw $t1 40($v0) + la $t1 function_Main_class_type + sw $t1 44($v0) + la $t1 function_Main_print + sw $t1 48($v0) + la $t1 function_Main_main + sw $t1 52($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type A + li $a0 40 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_A_method5 + sw $t1 36($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type B + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_A_method5 + sw $t1 36($v0) + la $t1 function_B_method5 + sw $t1 40($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type C + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + la $t1 function_C_method6 + sw $t1 40($v0) + la $t1 function_C_method5 + sw $t1 44($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type D + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + la $t1 function_D_method7 + sw $t1 40($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + # Type E + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_value + sw $t1 12($v0) + la $t1 function_A_set_var + sw $t1 16($v0) + la $t1 function_A_method1 + sw $t1 20($v0) + la $t1 function_A_method2 + sw $t1 24($v0) + la $t1 function_A_method3 + sw $t1 28($v0) + la $t1 function_A_method4 + sw $t1 32($v0) + la $t1 function_B_method5 + sw $t1 36($v0) + la $t1 function_D_method7 + sw $t1 40($v0) + la $t1 function_E_method6 + sw $t1 44($v0) + lw $t0 88($s0) + sw $v0 8($t0) + + # Type A2I + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A2I_c2i + sw $t1 12($v0) + la $t1 function_A2I_i2c + sw $t1 16($v0) + la $t1 function_A2I_a2i + sw $t1 20($v0) + la $t1 function_A2I_a2i_aux + sw $t1 24($v0) + la $t1 function_A2I_i2a + sw $t1 28($v0) + la $t1 function_A2I_i2a_aux + sw $t1 32($v0) + lw $t0 96($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 52 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 12 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 7 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 8 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 8 + sw $t1 0($t0) + + li $t0 11 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 10 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 24($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_menu: + move $fp, $sp + subu $sp, $sp, 392 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 32 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -96($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -112($fp) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -124($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -140($fp) + la $a0, data_7 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -140($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -132($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -132($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + lw $a2, -132($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -156($fp) + + # PUSHPARAM + lw $a0, -156($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + lw $a0 -172($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -168($fp) + la $a0, data_8 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -168($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -160($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -160($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + lw $a2, -160($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_9 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -184($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -200($fp) + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -192($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -192($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + lw $a2, -192($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + lw $a0 -216($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -212($fp) + la $a0, data_10 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -212($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -204($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -204($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + lw $a2, -204($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + li $a0, 9 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -232($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -228($fp) + la $a0, data_11 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -228($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -220($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -220($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + lw $a2, -220($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -244($fp) + + # PUSHPARAM + lw $a0, -244($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -236($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -236($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + lw $a2, -236($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_12 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -256($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_13 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -272($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -264($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -264($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + lw $a2, -264($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -288($fp) + + # PUSHPARAM + lw $a0, -288($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -280($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -280($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + lw $a2, -280($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -300($fp) + la $a0, data_14 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -300($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -292($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -292($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + lw $a2, -292($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -320($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -320($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -316($fp) + la $a0, data_15 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -316($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -308($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -308($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + lw $a2, -308($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -332($fp) + + # PUSHPARAM + lw $a0, -332($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -324($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -324($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + lw $a2, -324($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -344($fp) + la $a0, data_16 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -344($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -336($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -336($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -340($fp) + lw $a2, -336($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + li $a0, 32 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -360($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -360($fp) + lw $a0 -364($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -360($fp) + la $a0, data_17 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -360($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -352($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -352($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -356($fp) + lw $a2, -352($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -380($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -380($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + lw $a0 -380($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -376($fp) + la $a0, data_18 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -376($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -368($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -368($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + lw $a2, -368($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -384($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -384($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -388($fp) + lw $a2, -384($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -388($fp) + addiu $sp, $sp, 392 + jr $ra + +function_Main_prompt: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_19 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_20 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_Main_get_int: + move $fp, $sp + subu $sp, $sp, 24 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Main_is_even: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -44($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -36($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -64($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -56($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 2 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # - + lw $a0, -80($fp) + lw $a1, -84($fp) + sub $a0, $a0, $a1 + sw $a0, -76($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # - + li $a0 0 + lw $a1, -112($fp) + sub $a0, $a0, $a1 + sw $a0, -116($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -120($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 124 + jr $ra + +function_Main_class_type: + move $fp, $sp + subu $sp, $sp, 108 + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 11 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_6 + + # PUSHPARAM + li $a0, 9 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_7 + + # PUSHPARAM + li $a0, 10 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_8 + + # PUSHPARAM + li $a0, 8 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_9 + + # PUSHPARAM + li $a0, 7 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_10 + + # PUSHPARAM + li $a0, 1 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_11 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_21 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -16($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_7: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_22 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -32($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_23 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -48($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_9: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -68($fp) + la $a0, data_24 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -64($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_25 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_11: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_26 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_12: + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 108 + jr $ra + +function_Main_print: + move $fp, $sp + subu $sp, $sp, 48 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_27 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 48 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 1044 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 16($a1) + +_cil_label_LABEL_13: + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -16($fp) + + # GETATTR + lw $a1 -16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # IF GOTO + lw $a0, -12($fp) + bnez $a0, _cil_label_LABEL_14 + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_14: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -28($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -64($fp) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -64($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_16 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 8 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_29 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 9 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_30 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_17: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -116($fp) + + # PUSHPARAM + lw $a0, -116($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -120($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -120($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + lw $a2, -120($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -124($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -148($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -148($fp) + la $a0, data_31 + sw $a0 16($a1) + + lw $t0 -144($fp) + lw $t1 -148($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -136($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -136($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # IF GOTO + lw $a0, -132($fp) + bnez $a0, _cil_label_LABEL_18 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + lw $a0 -180($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -176($fp) + la $a0, data_32 + sw $a0 16($a1) + + lw $t0 -172($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -164($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -164($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -160($fp) + + # IF GOTO + lw $a0, -160($fp) + bnez $a0, _cil_label_LABEL_20 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -208($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -204($fp) + la $a0, data_33 + sw $a0 16($a1) + + lw $t0 -200($fp) + lw $t1 -204($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -192($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -192($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -196($fp) + lw $a0 12($a1) + sw $a0 -188($fp) + + # IF GOTO + lw $a0, -188($fp) + bnez $a0, _cil_label_LABEL_22 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -228($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_34 + sw $a0 16($a1) + + lw $t0 -228($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -220($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -220($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -224($fp) + lw $a0 12($a1) + sw $a0 -216($fp) + + # IF GOTO + lw $a0, -216($fp) + bnez $a0, _cil_label_LABEL_24 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -256($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + lw $a0 -264($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -260($fp) + la $a0, data_35 + sw $a0 16($a1) + + lw $t0 -256($fp) + lw $t1 -260($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_7 + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 -248($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 -248($fp) +end_equal_7_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + lw $a0 -248($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -252($fp) + lw $a0 12($a1) + sw $a0 -244($fp) + + # IF GOTO + lw $a0, -244($fp) + bnez $a0, _cil_label_LABEL_26 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -284($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_36 + sw $a0 16($a1) + + lw $t0 -284($fp) + lw $t1 -288($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_8 + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -276($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -276($fp) +end_equal_8_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -280($fp) + lw $a0 12($a1) + sw $a0 -272($fp) + + # IF GOTO + lw $a0, -272($fp) + bnez $a0, _cil_label_LABEL_28 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -312($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -320($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -320($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -316($fp) + la $a0, data_37 + sw $a0 16($a1) + + lw $t0 -312($fp) + lw $t1 -316($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_9 + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -304($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -304($fp) +end_equal_9_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -308($fp) + lw $a0 12($a1) + sw $a0 -300($fp) + + # IF GOTO + lw $a0, -300($fp) + bnez $a0, _cil_label_LABEL_30 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -340($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -344($fp) + la $a0, data_38 + sw $a0 16($a1) + + lw $t0 -340($fp) + lw $t1 -344($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_10 + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -332($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -332($fp) +end_equal_10_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + lw $a0 -332($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -336($fp) + lw $a0 12($a1) + sw $a0 -328($fp) + + # IF GOTO + lw $a0, -328($fp) + bnez $a0, _cil_label_LABEL_32 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -368($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -372($fp) + lw $a0 -376($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -372($fp) + la $a0, data_39 + sw $a0 16($a1) + + lw $t0 -368($fp) + lw $t1 -372($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_11 + li $a2 5 + beq $a0 $a2 _eq_int_bool_11 + li $a2 6 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -360($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -360($fp) +end_equal_11_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + lw $a0 -360($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -364($fp) + lw $a0 12($a1) + sw $a0 -356($fp) + + # IF GOTO + lw $a0, -356($fp) + bnez $a0, _cil_label_LABEL_34 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -396($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -404($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -404($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -400($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -400($fp) + lw $a0 -404($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -400($fp) + la $a0, data_40 + sw $a0 16($a1) + + lw $t0 -396($fp) + lw $t1 -400($fp) + beq $t0 $zero _eq_false_12_ + beq $t1 $zero _eq_false_12_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_12 + li $a2 5 + beq $a0 $a2 _eq_int_bool_12 + li $a2 6 + bne $a0 $a2 _not_basic_type_12_ +_eq_str_12_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_12_ + beq $t3 $0 _eq_true_12_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_12_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_12_ + b _eq_true_12_ +_not_basic_type_12_: + bne $t0 $t1 _eq_false_12_ + b _eq_true_12_ +_eq_int_bool_12: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_12_ +_eq_true_12_: + li $a0 1 + sw $a0 -388($fp) + b end_equal_12_ +_eq_false_12_: + li $a0 0 + sw $a0 -388($fp) +end_equal_12_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -392($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -392($fp) + lw $a0 -388($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -392($fp) + lw $a0 12($a1) + sw $a0 -384($fp) + + # IF GOTO + lw $a0, -384($fp) + bnez $a0, _cil_label_LABEL_36 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -408($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -408($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -412($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -424($fp) + + # PUSHPARAM + lw $a0, -424($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -424($fp) + lw $a0 0($a1) + sw $a0 -428($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -428($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -432($fp) + lw $a2, -428($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -432($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -408($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -408($fp) + lw $a0 0($a1) + sw $a0 -416($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -416($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -420($fp) + lw $a2, -416($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -420($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -420($fp) + sw $a0, -380($fp) + + # GOTO + j _cil_label_LABEL_37 + +_cil_label_LABEL_36: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -436($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -436($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -436($fp) + sw $a0 24($a1) + + # ASSIGN + lw $a0, -436($fp) + sw $a0, -380($fp) + +_cil_label_LABEL_37: + # ASSIGN + lw $a0, -380($fp) + sw $a0, -352($fp) + + # GOTO + j _cil_label_LABEL_35 + +_cil_label_LABEL_34: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -440($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -440($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -444($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -440($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -440($fp) + sw $a0, -352($fp) + +_cil_label_LABEL_35: + # ASSIGN + lw $a0, -352($fp) + sw $a0, -324($fp) + + # GOTO + j _cil_label_LABEL_33 + +_cil_label_LABEL_32: + # ALLOCATE + la $v0 type_void + sw $v0 -448($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -452($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -452($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -456($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -468($fp) + + # PUSHPARAM + lw $a0, -468($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -468($fp) + lw $a0 0($a1) + sw $a0 -472($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -472($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -476($fp) + lw $a2, -472($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -476($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -452($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -452($fp) + lw $a0 0($a1) + sw $a0 -460($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -460($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -464($fp) + lw $a2, -460($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -464($fp) + sw $a0, -448($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -496($fp) + + # PUSHPARAM + lw $a0, -496($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -496($fp) + lw $a0 0($a1) + sw $a0 -500($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -500($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -504($fp) + lw $a2, -500($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -448($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -448($fp) + lw $a0 0($a1) + sw $a0 -524($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -524($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -528($fp) + lw $a2, -524($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -532($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -532($fp) + li $a0, 8 + sw $a0 12($a1) + + # GETATTR + lw $a1 -528($fp) + lw $a0 12($a1) + sw $a0 -512($fp) + + # GETATTR + lw $a1 -532($fp) + lw $a0 12($a1) + sw $a0 -516($fp) + + # * + lw $a0, -512($fp) + lw $a1, -516($fp) + mul $a0, $a0, $a1 + sw $a0, -508($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -520($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -520($fp) + lw $a0 -508($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -504($fp) + lw $a0 12($a1) + sw $a0 -484($fp) + + # GETATTR + lw $a1 -520($fp) + lw $a0 12($a1) + sw $a0 -488($fp) + + # - + lw $a0, -484($fp) + lw $a1, -488($fp) + sub $a0, $a0, $a1 + sw $a0, -480($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -492($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -492($fp) + lw $a0 -480($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -548($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -548($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -544($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -544($fp) + lw $a0 -548($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -544($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -544($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -536($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -536($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -540($fp) + lw $a2, -536($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -560($fp) + + # PUSHPARAM + lw $a0, -560($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -552($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -552($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -556($fp) + lw $a2, -552($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -576($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -576($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -572($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -572($fp) + lw $a0 -576($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -572($fp) + la $a0, data_41 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -572($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -564($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -564($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -568($fp) + lw $a2, -564($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -448($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -580($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -580($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -584($fp) + lw $a2, -580($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -600($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -600($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -596($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -596($fp) + lw $a0 -600($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -596($fp) + la $a0, data_42 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -596($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -588($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -588($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -592($fp) + lw $a2, -588($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -604($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -604($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -608($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -492($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -604($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -604($fp) + lw $a0 0($a1) + sw $a0 -620($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -620($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -624($fp) + lw $a2, -620($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -624($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -612($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -612($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -616($fp) + lw $a2, -612($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -640($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -640($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -636($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -636($fp) + lw $a0 -640($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -636($fp) + la $a0, data_19 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -636($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -628($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -628($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -632($fp) + lw $a2, -628($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -448($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -448($fp) + sw $a0, -324($fp) + +_cil_label_LABEL_33: + # ASSIGN + lw $a0, -324($fp) + sw $a0, -296($fp) + + # GOTO + j _cil_label_LABEL_31 + +_cil_label_LABEL_30: + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -652($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -652($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -656($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -668($fp) + + # PUSHPARAM + lw $a0, -668($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -668($fp) + lw $a0 0($a1) + sw $a0 -672($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -672($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -676($fp) + lw $a2, -672($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -676($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -652($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -652($fp) + lw $a0 0($a1) + sw $a0 -660($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -660($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -664($fp) + lw $a2, -660($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -664($fp) + lw $a0 12($a1) + sw $a0 -648($fp) + + # IF GOTO + lw $a0, -648($fp) + bnez $a0, _cil_label_LABEL_38 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -692($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -692($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -688($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -688($fp) + lw $a0 -692($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -688($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -688($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -680($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -680($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -684($fp) + lw $a2, -680($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -704($fp) + + # PUSHPARAM + lw $a0, -704($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -696($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -696($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -700($fp) + lw $a2, -696($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -720($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -720($fp) + li $a0, 23 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -716($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -716($fp) + lw $a0 -720($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -716($fp) + la $a0, data_43 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -716($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -708($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -708($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -712($fp) + lw $a2, -708($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -712($fp) + sw $a0, -644($fp) + + # GOTO + j _cil_label_LABEL_39 + +_cil_label_LABEL_38: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -736($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -736($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -732($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -732($fp) + lw $a0 -736($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -732($fp) + la $a0, data_28 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -732($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -724($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -724($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -728($fp) + lw $a2, -724($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -748($fp) + + # PUSHPARAM + lw $a0, -748($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -740($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -740($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -744($fp) + lw $a2, -740($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -764($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -764($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -760($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -760($fp) + lw $a0 -764($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -760($fp) + la $a0, data_44 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -760($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -752($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -752($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -756($fp) + lw $a2, -752($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -756($fp) + sw $a0, -644($fp) + +_cil_label_LABEL_39: + # ASSIGN + lw $a0, -644($fp) + sw $a0, -296($fp) + +_cil_label_LABEL_31: + # ASSIGN + lw $a0, -296($fp) + sw $a0, -268($fp) + + # GOTO + j _cil_label_LABEL_29 + +_cil_label_LABEL_28: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -768($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -768($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -772($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -780($fp) + + # PUSHPARAM + lw $a0, -780($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -780($fp) + lw $a0 0($a1) + sw $a0 -784($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -784($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -788($fp) + lw $a2, -784($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -788($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -768($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 9 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -776($fp) + li $a2, 9 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -776($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -776($fp) + sw $a0, -268($fp) + +_cil_label_LABEL_29: + # ASSIGN + lw $a0, -268($fp) + sw $a0, -240($fp) + + # GOTO + j _cil_label_LABEL_27 + +_cil_label_LABEL_26: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -792($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -792($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -796($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -804($fp) + + # PUSHPARAM + lw $a0, -804($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -804($fp) + lw $a0 0($a1) + sw $a0 -808($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -808($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -812($fp) + lw $a2, -808($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -812($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -792($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 8 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -800($fp) + li $a2, 8 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -800($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -800($fp) + sw $a0, -240($fp) + +_cil_label_LABEL_27: + # ASSIGN + lw $a0, -240($fp) + sw $a0, -212($fp) + + # GOTO + j _cil_label_LABEL_25 + +_cil_label_LABEL_24: + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -816($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -816($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -820($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -828($fp) + + # PUSHPARAM + lw $a0, -828($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -828($fp) + lw $a0 0($a1) + sw $a0 -832($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -832($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -836($fp) + lw $a2, -832($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -836($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -816($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 7 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -824($fp) + li $a2, 7 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -824($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -824($fp) + sw $a0, -212($fp) + +_cil_label_LABEL_25: + # ASSIGN + lw $a0, -212($fp) + sw $a0, -184($fp) + + # GOTO + j _cil_label_LABEL_23 + +_cil_label_LABEL_22: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -840($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -840($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -844($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -856($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -856($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -860($fp) + lw $a2, -856($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -860($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -840($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -840($fp) + lw $a0 0($a1) + sw $a0 -848($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -848($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -852($fp) + lw $a2, -848($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -852($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -864($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -864($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -868($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -880($fp) + + # PUSHPARAM + lw $a0, -880($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -880($fp) + lw $a0 0($a1) + sw $a0 -884($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -884($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -888($fp) + lw $a2, -884($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -888($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -892($fp) + + # PUSHPARAM + lw $a0, -892($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -892($fp) + lw $a0 0($a1) + sw $a0 -896($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -896($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -900($fp) + lw $a2, -896($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -900($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -864($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -864($fp) + lw $a0 0($a1) + sw $a0 -872($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -872($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -876($fp) + lw $a2, -872($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -876($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -876($fp) + sw $a0, -184($fp) + +_cil_label_LABEL_23: + # ASSIGN + lw $a0, -184($fp) + sw $a0, -156($fp) + + # GOTO + j _cil_label_LABEL_21 + +_cil_label_LABEL_20: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -916($fp) + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -908($fp) + + # PUSHPARAM + li $a0, 9 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_40 + + # PUSHPARAM + li $a0, 7 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_41 + + # PUSHPARAM + li $a0, 1 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -908($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -904($fp) + bnez $a0, _cil_label_LABEL_42 + +_cil_label_LABEL_40: + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -928($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -928($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -932($fp) + lw $a2, -928($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -932($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -920($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -920($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -924($fp) + lw $a2, -920($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -924($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -924($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_41: + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -944($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -944($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -948($fp) + lw $a2, -944($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -948($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -916($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -916($fp) + lw $a0 0($a1) + sw $a0 -936($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -936($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -940($fp) + lw $a2, -936($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -940($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -940($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_42: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -964($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -964($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -960($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -960($fp) + lw $a0 -964($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -960($fp) + la $a0, data_26 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -960($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -952($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -952($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -956($fp) + lw $a2, -952($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -968($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -968($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -972($fp) + lw $a2, -968($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -976($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -976($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -976($fp) + sw $a0, -912($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_43: + # ASSIGN + lw $a0, -912($fp) + sw $a0, -156($fp) + +_cil_label_LABEL_21: + # ASSIGN + lw $a0, -156($fp) + sw $a0, -128($fp) + + # GOTO + j _cil_label_LABEL_19 + +_cil_label_LABEL_18: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -980($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -980($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -984($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -996($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -996($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1000($fp) + lw $a2, -996($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1000($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -980($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -980($fp) + lw $a0 0($a1) + sw $a0 -988($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -988($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -992($fp) + lw $a2, -988($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -992($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1004($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -1004($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1008($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -1020($fp) + + # PUSHPARAM + lw $a0, -1020($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1020($fp) + lw $a0 0($a1) + sw $a0 -1024($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1024($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1028($fp) + lw $a2, -1024($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1028($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -1032($fp) + + # PUSHPARAM + lw $a0, -1032($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1032($fp) + lw $a0 0($a1) + sw $a0 -1036($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1036($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1040($fp) + lw $a2, -1036($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -1040($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -1004($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -1004($fp) + lw $a0 0($a1) + sw $a0 -1012($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -1012($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -1016($fp) + lw $a2, -1012($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -1016($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -1016($fp) + sw $a0, -128($fp) + +_cil_label_LABEL_19: + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_15: + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 1044 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A_set_var: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A_method1: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A_method2: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # + + lw $a0, -8($fp) + lw $a1, -12($fp) + add $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_A_method3: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # - + li $a0 0 + lw $a1, -4($fp) + sub $a0, $a0, $a1 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -12($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_A_method4: + move $fp, $sp + subu $sp, $sp, 96 + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_44 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # - + lw $a0, -32($fp) + lw $a1, -36($fp) + sub $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -40($fp) + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -56($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_45 + +_cil_label_LABEL_44: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 20($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -60($fp) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -80($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -92($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_45: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 96 + jr $ra + +function_A_method5: + move $fp, $sp + subu $sp, $sp, 84 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 1 + sw $a0 12($a1) + +_cil_label_LABEL_46: + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # <= + lw $a1, -20($fp) + lw $a2, -24($fp) + sle $a0, $a1, $a2 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -28($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # IF GOTO + lw $a0, -12($fp) + bnez $a0, _cil_label_LABEL_47 + + # GOTO + j _cil_label_LABEL_48 + +_cil_label_LABEL_47: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # * + lw $a0, -36($fp) + lw $a1, -40($fp) + mul $a0, $a0, $a1 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -44($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # + + lw $a0, -52($fp) + lw $a1, -56($fp) + add $a0, $a0, $a1 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -4($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_48: + # ALLOCATE + la $v0 type_void + sw $v0 -8($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -68($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 84 + jr $ra + +function_B__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_B_method5: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # * + lw $a0, -8($fp) + lw $a1, -12($fp) + mul $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_C__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_C_method6: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # - + li $a0 0 + lw $a1, -4($fp) + sub $a0, $a0, $a1 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -12($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_C_method5: + move $fp, $sp + subu $sp, $sp, 52 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # * + lw $a0, -24($fp) + lw $a1, -28($fp) + mul $a0, $a0, $a1 + sw $a0, -20($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # * + lw $a0, -8($fp) + lw $a1, -12($fp) + mul $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_E__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -48($fp) + addiu $sp, $sp, 52 + jr $ra + +function_D__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_D_method7: + move $fp, $sp + subu $sp, $sp, 148 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_49 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -44($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_13 + li $a2 5 + beq $a0 $a2 _eq_int_bool_13 + li $a2 6 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -36($fp) +end_equal_13_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_51 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -64($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_14_ + beq $t1 $zero _eq_false_14_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_14 + li $a2 5 + beq $a0 $a2 _eq_int_bool_14 + li $a2 6 + bne $a0 $a2 _not_basic_type_14_ +_eq_str_14_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_14_ + beq $t3 $0 _eq_true_14_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_14_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_14_ + b _eq_true_14_ +_not_basic_type_14_: + bne $t0 $t1 _eq_false_14_ + b _eq_true_14_ +_eq_int_bool_14: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_14_ +_eq_true_14_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_14_ +_eq_false_14_: + li $a0 0 + sw $a0 -56($fp) +end_equal_14_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_53 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 -84($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_15 + li $a2 5 + beq $a0 $a2 _eq_int_bool_15 + li $a2 6 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -76($fp) +end_equal_15_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_55 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 3 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # - + lw $a0, -100($fp) + lw $a1, -104($fp) + sub $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -92($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_56 + +_cil_label_LABEL_55: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -116($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_56: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_54 + +_cil_label_LABEL_53: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_54: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_52 + +_cil_label_LABEL_51: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -124($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_52: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_50 + +_cil_label_LABEL_49: + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # - + li $a0 0 + lw $a1, -136($fp) + sub $a0, $a0, $a1 + sw $a0, -140($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -132($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_50: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 148 + jr $ra + +function_E__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_E_method6: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 8 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # / + lw $a0, -8($fp) + lw $a1, -12($fp) + beqz $a1 _div_error_16_ + div $a0, $a0, $a1 + sw $a0, -4($fp) + b _div_end_16_ +_div_error_16_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_16_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -16($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_A2I__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A2I_c2i: + move $fp, $sp + subu $sp, $sp, 292 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_45 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_17 + li $a2 5 + beq $a0 $a2 _eq_int_bool_17 + li $a2 6 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -8($fp) +end_equal_17_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_57 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_46 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_18_ + beq $t1 $zero _eq_false_18_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_18 + li $a2 5 + beq $a0 $a2 _eq_int_bool_18 + li $a2 6 + bne $a0 $a2 _not_basic_type_18_ +_eq_str_18_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_18_ + beq $t3 $0 _eq_true_18_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_18_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_18_ + b _eq_true_18_ +_not_basic_type_18_: + bne $t0 $t1 _eq_false_18_ + b _eq_true_18_ +_eq_int_bool_18: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_18_ +_eq_true_18_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_18_ +_eq_false_18_: + li $a0 0 + sw $a0 -32($fp) +end_equal_18_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_59 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_47 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_19 + li $a2 5 + beq $a0 $a2 _eq_int_bool_19 + li $a2 6 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -56($fp) +end_equal_19_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_61 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_48 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_20_ + beq $t1 $zero _eq_false_20_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_20 + li $a2 5 + beq $a0 $a2 _eq_int_bool_20 + li $a2 6 + bne $a0 $a2 _not_basic_type_20_ +_eq_str_20_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_20_ + beq $t3 $0 _eq_true_20_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_20_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_20_ + b _eq_true_20_ +_not_basic_type_20_: + bne $t0 $t1 _eq_false_20_ + b _eq_true_20_ +_eq_int_bool_20: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_20_ +_eq_true_20_: + li $a0 1 + sw $a0 -80($fp) + b end_equal_20_ +_eq_false_20_: + li $a0 0 + sw $a0 -80($fp) +end_equal_20_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_63 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_49 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_21_ + beq $t1 $zero _eq_false_21_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_21 + li $a2 5 + beq $a0 $a2 _eq_int_bool_21 + li $a2 6 + bne $a0 $a2 _not_basic_type_21_ +_eq_str_21_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_21_ + beq $t3 $0 _eq_true_21_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_21_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_21_ + b _eq_true_21_ +_not_basic_type_21_: + bne $t0 $t1 _eq_false_21_ + b _eq_true_21_ +_eq_int_bool_21: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_21_ +_eq_true_21_: + li $a0 1 + sw $a0 -104($fp) + b end_equal_21_ +_eq_false_21_: + li $a0 0 + sw $a0 -104($fp) +end_equal_21_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_65 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_50 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_22_ + beq $t1 $zero _eq_false_22_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_22 + li $a2 5 + beq $a0 $a2 _eq_int_bool_22 + li $a2 6 + bne $a0 $a2 _not_basic_type_22_ +_eq_str_22_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_22_ + beq $t3 $0 _eq_true_22_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_22_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_22_ + b _eq_true_22_ +_not_basic_type_22_: + bne $t0 $t1 _eq_false_22_ + b _eq_true_22_ +_eq_int_bool_22: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_22_ +_eq_true_22_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_22_ +_eq_false_22_: + li $a0 0 + sw $a0 -128($fp) +end_equal_22_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_67 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -160($fp) + la $a0, data_51 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -160($fp) + beq $t0 $zero _eq_false_23_ + beq $t1 $zero _eq_false_23_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_23 + li $a2 5 + beq $a0 $a2 _eq_int_bool_23 + li $a2 6 + bne $a0 $a2 _not_basic_type_23_ +_eq_str_23_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_23_ + beq $t3 $0 _eq_true_23_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_23_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_23_ + b _eq_true_23_ +_not_basic_type_23_: + bne $t0 $t1 _eq_false_23_ + b _eq_true_23_ +_eq_int_bool_23: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_23_ +_eq_true_23_: + li $a0 1 + sw $a0 -152($fp) + b end_equal_23_ +_eq_false_23_: + li $a0 0 + sw $a0 -152($fp) +end_equal_23_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -148($fp) + + # IF GOTO + lw $a0, -148($fp) + bnez $a0, _cil_label_LABEL_69 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_52 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -184($fp) + beq $t0 $zero _eq_false_24_ + beq $t1 $zero _eq_false_24_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_24 + li $a2 5 + beq $a0 $a2 _eq_int_bool_24 + li $a2 6 + bne $a0 $a2 _not_basic_type_24_ +_eq_str_24_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_24_ + beq $t3 $0 _eq_true_24_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_24_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_24_ + b _eq_true_24_ +_not_basic_type_24_: + bne $t0 $t1 _eq_false_24_ + b _eq_true_24_ +_eq_int_bool_24: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_24_ +_eq_true_24_: + li $a0 1 + sw $a0 -176($fp) + b end_equal_24_ +_eq_false_24_: + li $a0 0 + sw $a0 -176($fp) +end_equal_24_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # IF GOTO + lw $a0, -172($fp) + bnez $a0, _cil_label_LABEL_71 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_53 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -208($fp) + beq $t0 $zero _eq_false_25_ + beq $t1 $zero _eq_false_25_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_25 + li $a2 5 + beq $a0 $a2 _eq_int_bool_25 + li $a2 6 + bne $a0 $a2 _not_basic_type_25_ +_eq_str_25_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_25_ + beq $t3 $0 _eq_true_25_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_25_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_25_ + b _eq_true_25_ +_not_basic_type_25_: + bne $t0 $t1 _eq_false_25_ + b _eq_true_25_ +_eq_int_bool_25: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_25_ +_eq_true_25_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_25_ +_eq_false_25_: + li $a0 0 + sw $a0 -200($fp) +end_equal_25_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_73 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_54 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_26_ + beq $t1 $zero _eq_false_26_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_26 + li $a2 5 + beq $a0 $a2 _eq_int_bool_26 + li $a2 6 + bne $a0 $a2 _not_basic_type_26_ +_eq_str_26_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_26_ + beq $t3 $0 _eq_true_26_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_26_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_26_ + b _eq_true_26_ +_not_basic_type_26_: + bne $t0 $t1 _eq_false_26_ + b _eq_true_26_ +_eq_int_bool_26: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_26_ +_eq_true_26_: + li $a0 1 + sw $a0 -224($fp) + b end_equal_26_ +_eq_false_26_: + li $a0 0 + sw $a0 -224($fp) +end_equal_26_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -228($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # IF GOTO + lw $a0, -220($fp) + bnez $a0, _cil_label_LABEL_75 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -240($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -240($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + lw $a2, -240($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -216($fp) + + # GOTO + j _cil_label_LABEL_76 + +_cil_label_LABEL_75: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 9 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -252($fp) + sw $a0, -216($fp) + +_cil_label_LABEL_76: + # ASSIGN + lw $a0, -216($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_74 + +_cil_label_LABEL_73: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + li $a0, 8 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_74: + # ASSIGN + lw $a0, -192($fp) + sw $a0, -168($fp) + + # GOTO + j _cil_label_LABEL_72 + +_cil_label_LABEL_71: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 7 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -260($fp) + sw $a0, -168($fp) + +_cil_label_LABEL_72: + # ASSIGN + lw $a0, -168($fp) + sw $a0, -144($fp) + + # GOTO + j _cil_label_LABEL_70 + +_cil_label_LABEL_69: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + li $a0, 6 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -144($fp) + +_cil_label_LABEL_70: + # ASSIGN + lw $a0, -144($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_68 + +_cil_label_LABEL_67: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 5 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -268($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_68: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -96($fp) + + # GOTO + j _cil_label_LABEL_66 + +_cil_label_LABEL_65: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 4 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -96($fp) + +_cil_label_LABEL_66: + # ASSIGN + lw $a0, -96($fp) + sw $a0, -72($fp) + + # GOTO + j _cil_label_LABEL_64 + +_cil_label_LABEL_63: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 3 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -276($fp) + sw $a0, -72($fp) + +_cil_label_LABEL_64: + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_62 + +_cil_label_LABEL_61: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + li $a0, 2 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_62: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_60 + +_cil_label_LABEL_59: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -284($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_60: + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_58 + +_cil_label_LABEL_57: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_58: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 292 + jr $ra + +function_A2I_i2c: + move $fp, $sp + subu $sp, $sp, 296 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_27_ + beq $t1 $zero _eq_false_27_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_27 + li $a2 5 + beq $a0 $a2 _eq_int_bool_27 + li $a2 6 + bne $a0 $a2 _not_basic_type_27_ +_eq_str_27_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_27_ + beq $t3 $0 _eq_true_27_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_27_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_27_ + b _eq_true_27_ +_not_basic_type_27_: + bne $t0 $t1 _eq_false_27_ + b _eq_true_27_ +_eq_int_bool_27: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_27_ +_eq_true_27_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_27_ +_eq_false_27_: + li $a0 0 + sw $a0 -8($fp) +end_equal_27_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_77 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -36($fp) + beq $t0 $zero _eq_false_28_ + beq $t1 $zero _eq_false_28_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_28 + li $a2 5 + beq $a0 $a2 _eq_int_bool_28 + li $a2 6 + bne $a0 $a2 _not_basic_type_28_ +_eq_str_28_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_28_ + beq $t3 $0 _eq_true_28_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_28_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_28_ + b _eq_true_28_ +_not_basic_type_28_: + bne $t0 $t1 _eq_false_28_ + b _eq_true_28_ +_eq_int_bool_28: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_28_ +_eq_true_28_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_28_ +_eq_false_28_: + li $a0 0 + sw $a0 -28($fp) +end_equal_28_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_79 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_29_ + beq $t1 $zero _eq_false_29_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_29 + li $a2 5 + beq $a0 $a2 _eq_int_bool_29 + li $a2 6 + bne $a0 $a2 _not_basic_type_29_ +_eq_str_29_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_29_ + beq $t3 $0 _eq_true_29_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_29_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_29_ + b _eq_true_29_ +_not_basic_type_29_: + bne $t0 $t1 _eq_false_29_ + b _eq_true_29_ +_eq_int_bool_29: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_29_ +_eq_true_29_: + li $a0 1 + sw $a0 -48($fp) + b end_equal_29_ +_eq_false_29_: + li $a0 0 + sw $a0 -48($fp) +end_equal_29_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_81 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_30_ + beq $t1 $zero _eq_false_30_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_30 + li $a2 5 + beq $a0 $a2 _eq_int_bool_30 + li $a2 6 + bne $a0 $a2 _not_basic_type_30_ +_eq_str_30_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_30_ + beq $t3 $0 _eq_true_30_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_30_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_30_ + b _eq_true_30_ +_not_basic_type_30_: + bne $t0 $t1 _eq_false_30_ + b _eq_true_30_ +_eq_int_bool_30: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_30_ +_eq_true_30_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_30_ +_eq_false_30_: + li $a0 0 + sw $a0 -68($fp) +end_equal_30_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_83 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 4 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -96($fp) + beq $t0 $zero _eq_false_31_ + beq $t1 $zero _eq_false_31_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_31 + li $a2 5 + beq $a0 $a2 _eq_int_bool_31 + li $a2 6 + bne $a0 $a2 _not_basic_type_31_ +_eq_str_31_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_31_ + beq $t3 $0 _eq_true_31_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_31_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_31_ + b _eq_true_31_ +_not_basic_type_31_: + bne $t0 $t1 _eq_false_31_ + b _eq_true_31_ +_eq_int_bool_31: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_31_ +_eq_true_31_: + li $a0 1 + sw $a0 -88($fp) + b end_equal_31_ +_eq_false_31_: + li $a0 0 + sw $a0 -88($fp) +end_equal_31_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_85 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 5 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -116($fp) + beq $t0 $zero _eq_false_32_ + beq $t1 $zero _eq_false_32_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_32 + li $a2 5 + beq $a0 $a2 _eq_int_bool_32 + li $a2 6 + bne $a0 $a2 _not_basic_type_32_ +_eq_str_32_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_32_ + beq $t3 $0 _eq_true_32_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_32_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_32_ + b _eq_true_32_ +_not_basic_type_32_: + bne $t0 $t1 _eq_false_32_ + b _eq_true_32_ +_eq_int_bool_32: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_32_ +_eq_true_32_: + li $a0 1 + sw $a0 -108($fp) + b end_equal_32_ +_eq_false_32_: + li $a0 0 + sw $a0 -108($fp) +end_equal_32_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # IF GOTO + lw $a0, -104($fp) + bnez $a0, _cil_label_LABEL_87 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 6 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_33_ + beq $t1 $zero _eq_false_33_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_33 + li $a2 5 + beq $a0 $a2 _eq_int_bool_33 + li $a2 6 + bne $a0 $a2 _not_basic_type_33_ +_eq_str_33_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_33_ + beq $t3 $0 _eq_true_33_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_33_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_33_ + b _eq_true_33_ +_not_basic_type_33_: + bne $t0 $t1 _eq_false_33_ + b _eq_true_33_ +_eq_int_bool_33: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_33_ +_eq_true_33_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_33_ +_eq_false_33_: + li $a0 0 + sw $a0 -128($fp) +end_equal_33_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_89 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 7 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -156($fp) + beq $t0 $zero _eq_false_34_ + beq $t1 $zero _eq_false_34_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_34 + li $a2 5 + beq $a0 $a2 _eq_int_bool_34 + li $a2 6 + bne $a0 $a2 _not_basic_type_34_ +_eq_str_34_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_34_ + beq $t3 $0 _eq_true_34_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_34_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_34_ + b _eq_true_34_ +_not_basic_type_34_: + bne $t0 $t1 _eq_false_34_ + b _eq_true_34_ +_eq_int_bool_34: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_34_ +_eq_true_34_: + li $a0 1 + sw $a0 -148($fp) + b end_equal_34_ +_eq_false_34_: + li $a0 0 + sw $a0 -148($fp) +end_equal_34_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # IF GOTO + lw $a0, -144($fp) + bnez $a0, _cil_label_LABEL_91 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 8 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_35_ + beq $t1 $zero _eq_false_35_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_35 + li $a2 5 + beq $a0 $a2 _eq_int_bool_35 + li $a2 6 + bne $a0 $a2 _not_basic_type_35_ +_eq_str_35_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_35_ + beq $t3 $0 _eq_true_35_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_35_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_35_ + b _eq_true_35_ +_not_basic_type_35_: + bne $t0 $t1 _eq_false_35_ + b _eq_true_35_ +_eq_int_bool_35: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_35_ +_eq_true_35_: + li $a0 1 + sw $a0 -168($fp) + b end_equal_35_ +_eq_false_35_: + li $a0 0 + sw $a0 -168($fp) +end_equal_35_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # IF GOTO + lw $a0, -164($fp) + bnez $a0, _cil_label_LABEL_93 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + li $a0, 9 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -196($fp) + beq $t0 $zero _eq_false_36_ + beq $t1 $zero _eq_false_36_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_36 + li $a2 5 + beq $a0 $a2 _eq_int_bool_36 + li $a2 6 + bne $a0 $a2 _not_basic_type_36_ +_eq_str_36_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_36_ + beq $t3 $0 _eq_true_36_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_36_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_36_ + b _eq_true_36_ +_not_basic_type_36_: + bne $t0 $t1 _eq_false_36_ + b _eq_true_36_ +_eq_int_bool_36: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_36_ +_eq_true_36_: + li $a0 1 + sw $a0 -188($fp) + b end_equal_36_ +_eq_false_36_: + li $a0 0 + sw $a0 -188($fp) +end_equal_36_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -192($fp) + lw $a0 12($a1) + sw $a0 -184($fp) + + # IF GOTO + lw $a0, -184($fp) + bnez $a0, _cil_label_LABEL_95 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -200($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -200($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + lw $a2, -200($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -208($fp) + sw $a0, -180($fp) + + # GOTO + j _cil_label_LABEL_96 + +_cil_label_LABEL_95: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -216($fp) + la $a0, data_54 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -216($fp) + sw $a0, -180($fp) + +_cil_label_LABEL_96: + # ASSIGN + lw $a0, -180($fp) + sw $a0, -160($fp) + + # GOTO + j _cil_label_LABEL_94 + +_cil_label_LABEL_93: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + lw $a0 -228($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -224($fp) + la $a0, data_53 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, -160($fp) + +_cil_label_LABEL_94: + # ASSIGN + lw $a0, -160($fp) + sw $a0, -140($fp) + + # GOTO + j _cil_label_LABEL_92 + +_cil_label_LABEL_91: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_52 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -232($fp) + sw $a0, -140($fp) + +_cil_label_LABEL_92: + # ASSIGN + lw $a0, -140($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_90 + +_cil_label_LABEL_89: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -244($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -240($fp) + la $a0, data_51 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -240($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_90: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -100($fp) + + # GOTO + j _cil_label_LABEL_88 + +_cil_label_LABEL_87: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + lw $a0 -252($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -248($fp) + la $a0, data_50 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -100($fp) + +_cil_label_LABEL_88: + # ASSIGN + lw $a0, -100($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_86 + +_cil_label_LABEL_85: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_49 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_86: + # ASSIGN + lw $a0, -80($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_84 + +_cil_label_LABEL_83: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + lw $a0 -268($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -264($fp) + la $a0, data_48 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_84: + # ASSIGN + lw $a0, -60($fp) + sw $a0, -40($fp) + + # GOTO + j _cil_label_LABEL_82 + +_cil_label_LABEL_81: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_47 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -40($fp) + +_cil_label_LABEL_82: + # ASSIGN + lw $a0, -40($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_80 + +_cil_label_LABEL_79: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -284($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -280($fp) + la $a0, data_46 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_80: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_78 + +_cil_label_LABEL_77: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_45 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_78: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 296 + jr $ra + +function_A2I_a2i: + move $fp, $sp + subu $sp, $sp, 228 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_37_ + beq $t1 $zero _eq_false_37_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_37 + li $a2 5 + beq $a0 $a2 _eq_int_bool_37 + li $a2 6 + bne $a0 $a2 _not_basic_type_37_ +_eq_str_37_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_37_ + beq $t3 $0 _eq_true_37_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_37_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_37_ + b _eq_true_37_ +_not_basic_type_37_: + bne $t0 $t1 _eq_false_37_ + b _eq_true_37_ +_eq_int_bool_37: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_37_ +_eq_true_37_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_37_ +_eq_false_37_: + li $a0 0 + sw $a0 -8($fp) +end_equal_37_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_97 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_55 + sw $a0 16($a1) + + lw $t0 -48($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_38_ + beq $t1 $zero _eq_false_38_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_38 + li $a2 5 + beq $a0 $a2 _eq_int_bool_38 + li $a2 6 + bne $a0 $a2 _not_basic_type_38_ +_eq_str_38_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_38_ + beq $t3 $0 _eq_true_38_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_38_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_38_ + b _eq_true_38_ +_not_basic_type_38_: + bne $t0 $t1 _eq_false_38_ + b _eq_true_38_ +_eq_int_bool_38: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_38_ +_eq_true_38_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_38_ +_eq_false_38_: + li $a0 0 + sw $a0 -36($fp) +end_equal_38_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_99 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_56 + sw $a0 16($a1) + + lw $t0 -88($fp) + lw $t1 -100($fp) + beq $t0 $zero _eq_false_39_ + beq $t1 $zero _eq_false_39_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_39 + li $a2 5 + beq $a0 $a2 _eq_int_bool_39 + li $a2 6 + bne $a0 $a2 _not_basic_type_39_ +_eq_str_39_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_39_ + beq $t3 $0 _eq_true_39_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_39_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_39_ + b _eq_true_39_ +_not_basic_type_39_: + bne $t0 $t1 _eq_false_39_ + b _eq_true_39_ +_eq_int_bool_39: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_39_ +_eq_true_39_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_39_ +_eq_false_39_: + li $a0 0 + sw $a0 -76($fp) +end_equal_39_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_101 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_102 + +_cil_label_LABEL_101: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -140($fp) + + # - + lw $a0, -136($fp) + lw $a1, -140($fp) + sub $a0, $a0, $a1 + sw $a0, -132($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -132($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -128($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_102: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_100 + +_cil_label_LABEL_99: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -212($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # GETATTR + lw $a1 -216($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # - + lw $a0, -196($fp) + lw $a1, -200($fp) + sub $a0, $a0, $a1 + sw $a0, -192($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -184($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -184($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + lw $a2, -184($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # - + li $a0 0 + lw $a1, -164($fp) + sub $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_100: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_98 + +_cil_label_LABEL_97: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_98: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 228 + jr $ra + +function_A2I_a2i_aux: + move $fp, $sp + subu $sp, $sp, 116 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_103: + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_104 + + # GOTO + j _cil_label_LABEL_105 + +_cil_label_LABEL_104: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # * + lw $a0, -60($fp) + lw $a1, -64($fp) + mul $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # + + lw $a0, -44($fp) + lw $a1, -48($fp) + add $a0, $a0, $a1 + sw $a0, -40($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_103 + +_cil_label_LABEL_105: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 116 + jr $ra + +function_A2I_i2a: + move $fp, $sp + subu $sp, $sp, 120 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_40_ + beq $t1 $zero _eq_false_40_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_40 + li $a2 5 + beq $a0 $a2 _eq_int_bool_40 + li $a2 6 + bne $a0 $a2 _not_basic_type_40_ +_eq_str_40_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_40_ + beq $t3 $0 _eq_true_40_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_40_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_40_ + b _eq_true_40_ +_not_basic_type_40_: + bne $t0 $t1 _eq_false_40_ + b _eq_true_40_ +_eq_int_bool_40: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_40_ +_eq_true_40_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_40_ +_eq_false_40_: + li $a0 0 + sw $a0 -8($fp) +end_equal_40_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_106 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # < + lw $a1, -32($fp) + lw $a2, -36($fp) + slt $a0, $a1, $a2 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_108 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_55 + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # - + li $a0 0 + lw $a1, -88($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # * + lw $a0, -76($fp) + lw $a1, -80($fp) + mul $a0, $a0, $a1 + sw $a0, -72($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_109 + +_cil_label_LABEL_108: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_109: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_107 + +_cil_label_LABEL_106: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_45 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_107: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_A2I_i2a_aux: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_41_ + beq $t1 $zero _eq_false_41_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_41 + li $a2 5 + beq $a0 $a2 _eq_int_bool_41 + li $a2 6 + bne $a0 $a2 _not_basic_type_41_ +_eq_str_41_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_41_ + beq $t3 $0 _eq_true_41_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_41_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_41_ + b _eq_true_41_ +_not_basic_type_41_: + bne $t0 $t1 _eq_false_41_ + b _eq_true_41_ +_eq_int_bool_41: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_41_ +_eq_true_41_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_41_ +_eq_false_41_: + li $a0 0 + sw $a0 -8($fp) +end_equal_41_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_110 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # / + lw $a0, -24($fp) + lw $a1, -28($fp) + beqz $a1 _div_error_42_ + div $a0, $a0, $a1 + sw $a0, -20($fp) + b _div_end_42_ +_div_error_42_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_42_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # * + lw $a0, -84($fp) + lw $a1, -88($fp) + mul $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_111 + +_cil_label_LABEL_110: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_111: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/atoi.mips b/tests/codegen/atoi.mips new file mode 100644 index 00000000..eeed088a --- /dev/null +++ b/tests/codegen/atoi.mips @@ -0,0 +1,7719 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "678987" + data_2: .align 2 + .asciiz " == " + data_3: .align 2 + .asciiz "\n" + data_4: .align 2 + .asciiz "0" + data_5: .align 2 + .asciiz "1" + data_6: .align 2 + .asciiz "2" + data_7: .align 2 + .asciiz "3" + data_8: .align 2 + .asciiz "4" + data_9: .align 2 + .asciiz "5" + data_10: .align 2 + .asciiz "6" + data_11: .align 2 + .asciiz "7" + data_12: .align 2 + .asciiz "8" + data_13: .align 2 + .asciiz "9" + data_14: .align 2 + .asciiz "Abort called from class A2I\n" + data_15: .align 2 + .asciiz "-" + data_16: .align 2 + .asciiz "+" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_A2I: .align 2 + .asciiz "A2I" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_A2I + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type A2I + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type A2I + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A2I_c2i + sw $t1 12($v0) + la $t1 function_A2I_i2c + sw $t1 16($v0) + la $t1 function_A2I_a2i + sw $t1 20($v0) + la $t1 function_A2I_a2i_aux + sw $t1 24($v0) + la $t1 function_A2I_i2a + sw $t1 28($v0) + la $t1 function_A2I_i2a_aux + sw $t1 32($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 6 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 678987 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A2I__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A2I_c2i: + move $fp, $sp + subu $sp, $sp, 316 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_5 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -32($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_6 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -56($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_7 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -80($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -80($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_8 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -104($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -104($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_9 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -128($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -160($fp) + la $a0, data_10 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -160($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_7 + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 -152($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 -152($fp) +end_equal_7_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -148($fp) + + # IF GOTO + lw $a0, -148($fp) + bnez $a0, _cil_label_LABEL_12 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_11 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -184($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_8 + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -176($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -176($fp) +end_equal_8_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # IF GOTO + lw $a0, -172($fp) + bnez $a0, _cil_label_LABEL_14 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_12 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -208($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_9 + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -200($fp) +end_equal_9_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_16 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_13 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_10 + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -224($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -224($fp) +end_equal_10_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -228($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # IF GOTO + lw $a0, -220($fp) + bnez $a0, _cil_label_LABEL_18 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_14 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -256($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -240($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -264($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -264($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + lw $a2, -264($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -216($fp) + + # GOTO + j _cil_label_LABEL_19 + +_cil_label_LABEL_18: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 9 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -276($fp) + sw $a0, -216($fp) + +_cil_label_LABEL_19: + # ASSIGN + lw $a0, -216($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + li $a0, 8 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_17: + # ASSIGN + lw $a0, -192($fp) + sw $a0, -168($fp) + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_14: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 7 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -284($fp) + sw $a0, -168($fp) + +_cil_label_LABEL_15: + # ASSIGN + lw $a0, -168($fp) + sw $a0, -144($fp) + + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_12: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 6 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, -144($fp) + +_cil_label_LABEL_13: + # ASSIGN + lw $a0, -144($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 5 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -292($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_11: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -96($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + li $a0, 4 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -296($fp) + sw $a0, -96($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -96($fp) + sw $a0, -72($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 3 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -300($fp) + sw $a0, -72($fp) + +_cil_label_LABEL_7: + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 2 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -308($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -312($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -312($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 316 + jr $ra + +function_A2I_i2c: + move $fp, $sp + subu $sp, $sp, 320 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_11 + li $a2 5 + beq $a0 $a2 _eq_int_bool_11 + li $a2 6 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -8($fp) +end_equal_11_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_20 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -36($fp) + beq $t0 $zero _eq_false_12_ + beq $t1 $zero _eq_false_12_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_12 + li $a2 5 + beq $a0 $a2 _eq_int_bool_12 + li $a2 6 + bne $a0 $a2 _not_basic_type_12_ +_eq_str_12_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_12_ + beq $t3 $0 _eq_true_12_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_12_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_12_ + b _eq_true_12_ +_not_basic_type_12_: + bne $t0 $t1 _eq_false_12_ + b _eq_true_12_ +_eq_int_bool_12: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_12_ +_eq_true_12_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_12_ +_eq_false_12_: + li $a0 0 + sw $a0 -28($fp) +end_equal_12_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_22 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_13 + li $a2 5 + beq $a0 $a2 _eq_int_bool_13 + li $a2 6 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -48($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -48($fp) +end_equal_13_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_24 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_14_ + beq $t1 $zero _eq_false_14_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_14 + li $a2 5 + beq $a0 $a2 _eq_int_bool_14 + li $a2 6 + bne $a0 $a2 _not_basic_type_14_ +_eq_str_14_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_14_ + beq $t3 $0 _eq_true_14_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_14_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_14_ + b _eq_true_14_ +_not_basic_type_14_: + bne $t0 $t1 _eq_false_14_ + b _eq_true_14_ +_eq_int_bool_14: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_14_ +_eq_true_14_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_14_ +_eq_false_14_: + li $a0 0 + sw $a0 -68($fp) +end_equal_14_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_26 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 4 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -96($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_15 + li $a2 5 + beq $a0 $a2 _eq_int_bool_15 + li $a2 6 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -88($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -88($fp) +end_equal_15_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_28 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 5 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -116($fp) + beq $t0 $zero _eq_false_16_ + beq $t1 $zero _eq_false_16_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_16 + li $a2 5 + beq $a0 $a2 _eq_int_bool_16 + li $a2 6 + bne $a0 $a2 _not_basic_type_16_ +_eq_str_16_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_16_ + beq $t3 $0 _eq_true_16_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_16_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_16_ + b _eq_true_16_ +_not_basic_type_16_: + bne $t0 $t1 _eq_false_16_ + b _eq_true_16_ +_eq_int_bool_16: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_16_ +_eq_true_16_: + li $a0 1 + sw $a0 -108($fp) + b end_equal_16_ +_eq_false_16_: + li $a0 0 + sw $a0 -108($fp) +end_equal_16_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # IF GOTO + lw $a0, -104($fp) + bnez $a0, _cil_label_LABEL_30 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 6 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_17 + li $a2 5 + beq $a0 $a2 _eq_int_bool_17 + li $a2 6 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -128($fp) +end_equal_17_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_32 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 7 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -156($fp) + beq $t0 $zero _eq_false_18_ + beq $t1 $zero _eq_false_18_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_18 + li $a2 5 + beq $a0 $a2 _eq_int_bool_18 + li $a2 6 + bne $a0 $a2 _not_basic_type_18_ +_eq_str_18_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_18_ + beq $t3 $0 _eq_true_18_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_18_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_18_ + b _eq_true_18_ +_not_basic_type_18_: + bne $t0 $t1 _eq_false_18_ + b _eq_true_18_ +_eq_int_bool_18: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_18_ +_eq_true_18_: + li $a0 1 + sw $a0 -148($fp) + b end_equal_18_ +_eq_false_18_: + li $a0 0 + sw $a0 -148($fp) +end_equal_18_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # IF GOTO + lw $a0, -144($fp) + bnez $a0, _cil_label_LABEL_34 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 8 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_19 + li $a2 5 + beq $a0 $a2 _eq_int_bool_19 + li $a2 6 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -168($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -168($fp) +end_equal_19_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # IF GOTO + lw $a0, -164($fp) + bnez $a0, _cil_label_LABEL_36 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + li $a0, 9 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -196($fp) + beq $t0 $zero _eq_false_20_ + beq $t1 $zero _eq_false_20_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_20 + li $a2 5 + beq $a0 $a2 _eq_int_bool_20 + li $a2 6 + bne $a0 $a2 _not_basic_type_20_ +_eq_str_20_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_20_ + beq $t3 $0 _eq_true_20_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_20_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_20_ + b _eq_true_20_ +_not_basic_type_20_: + bne $t0 $t1 _eq_false_20_ + b _eq_true_20_ +_eq_int_bool_20: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_20_ +_eq_true_20_: + li $a0 1 + sw $a0 -188($fp) + b end_equal_20_ +_eq_false_20_: + li $a0 0 + sw $a0 -188($fp) +end_equal_20_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -192($fp) + lw $a0 12($a1) + sw $a0 -184($fp) + + # IF GOTO + lw $a0, -184($fp) + bnez $a0, _cil_label_LABEL_38 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -216($fp) + la $a0, data_14 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -216($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -200($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -200($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -224($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -224($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + lw $a2, -224($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -232($fp) + sw $a0, -180($fp) + + # GOTO + j _cil_label_LABEL_39 + +_cil_label_LABEL_38: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -244($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -240($fp) + la $a0, data_13 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -240($fp) + sw $a0, -180($fp) + +_cil_label_LABEL_39: + # ASSIGN + lw $a0, -180($fp) + sw $a0, -160($fp) + + # GOTO + j _cil_label_LABEL_37 + +_cil_label_LABEL_36: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + lw $a0 -252($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -248($fp) + la $a0, data_12 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -160($fp) + +_cil_label_LABEL_37: + # ASSIGN + lw $a0, -160($fp) + sw $a0, -140($fp) + + # GOTO + j _cil_label_LABEL_35 + +_cil_label_LABEL_34: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_11 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -140($fp) + +_cil_label_LABEL_35: + # ASSIGN + lw $a0, -140($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_33 + +_cil_label_LABEL_32: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + lw $a0 -268($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -264($fp) + la $a0, data_10 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_33: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -100($fp) + + # GOTO + j _cil_label_LABEL_31 + +_cil_label_LABEL_30: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_9 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -100($fp) + +_cil_label_LABEL_31: + # ASSIGN + lw $a0, -100($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_29 + +_cil_label_LABEL_28: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -284($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -280($fp) + la $a0, data_8 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_29: + # ASSIGN + lw $a0, -80($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_27 + +_cil_label_LABEL_26: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_7 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_27: + # ASSIGN + lw $a0, -60($fp) + sw $a0, -40($fp) + + # GOTO + j _cil_label_LABEL_25 + +_cil_label_LABEL_24: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + lw $a0 -300($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -296($fp) + la $a0, data_6 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -296($fp) + sw $a0, -40($fp) + +_cil_label_LABEL_25: + # ASSIGN + lw $a0, -40($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_23 + +_cil_label_LABEL_22: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + lw $a0 -308($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -304($fp) + la $a0, data_5 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_23: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_21 + +_cil_label_LABEL_20: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -312($fp) + lw $a0 -316($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -312($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -312($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_21: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 320 + jr $ra + +function_A2I_a2i: + move $fp, $sp + subu $sp, $sp, 228 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_21_ + beq $t1 $zero _eq_false_21_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_21 + li $a2 5 + beq $a0 $a2 _eq_int_bool_21 + li $a2 6 + bne $a0 $a2 _not_basic_type_21_ +_eq_str_21_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_21_ + beq $t3 $0 _eq_true_21_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_21_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_21_ + b _eq_true_21_ +_not_basic_type_21_: + bne $t0 $t1 _eq_false_21_ + b _eq_true_21_ +_eq_int_bool_21: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_21_ +_eq_true_21_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_21_ +_eq_false_21_: + li $a0 0 + sw $a0 -8($fp) +end_equal_21_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_40 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_15 + sw $a0 16($a1) + + lw $t0 -48($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_22_ + beq $t1 $zero _eq_false_22_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_22 + li $a2 5 + beq $a0 $a2 _eq_int_bool_22 + li $a2 6 + bne $a0 $a2 _not_basic_type_22_ +_eq_str_22_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_22_ + beq $t3 $0 _eq_true_22_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_22_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_22_ + b _eq_true_22_ +_not_basic_type_22_: + bne $t0 $t1 _eq_false_22_ + b _eq_true_22_ +_eq_int_bool_22: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_22_ +_eq_true_22_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_22_ +_eq_false_22_: + li $a0 0 + sw $a0 -36($fp) +end_equal_22_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_42 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_16 + sw $a0 16($a1) + + lw $t0 -88($fp) + lw $t1 -100($fp) + beq $t0 $zero _eq_false_23_ + beq $t1 $zero _eq_false_23_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_23 + li $a2 5 + beq $a0 $a2 _eq_int_bool_23 + li $a2 6 + bne $a0 $a2 _not_basic_type_23_ +_eq_str_23_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_23_ + beq $t3 $0 _eq_true_23_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_23_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_23_ + b _eq_true_23_ +_not_basic_type_23_: + bne $t0 $t1 _eq_false_23_ + b _eq_true_23_ +_eq_int_bool_23: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_23_ +_eq_true_23_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_23_ +_eq_false_23_: + li $a0 0 + sw $a0 -76($fp) +end_equal_23_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_44 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_45 + +_cil_label_LABEL_44: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -140($fp) + + # - + lw $a0, -136($fp) + lw $a1, -140($fp) + sub $a0, $a0, $a1 + sw $a0, -132($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -132($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -128($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_45: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_42: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -212($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # GETATTR + lw $a1 -216($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # - + lw $a0, -196($fp) + lw $a1, -200($fp) + sub $a0, $a0, $a1 + sw $a0, -192($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -184($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -184($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + lw $a2, -184($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # - + li $a0 0 + lw $a1, -164($fp) + sub $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_43: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_41 + +_cil_label_LABEL_40: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_41: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 228 + jr $ra + +function_A2I_a2i_aux: + move $fp, $sp + subu $sp, $sp, 116 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_46: + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_47 + + # GOTO + j _cil_label_LABEL_48 + +_cil_label_LABEL_47: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # * + lw $a0, -60($fp) + lw $a1, -64($fp) + mul $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # + + lw $a0, -44($fp) + lw $a1, -48($fp) + add $a0, $a0, $a1 + sw $a0, -40($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_48: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 116 + jr $ra + +function_A2I_i2a: + move $fp, $sp + subu $sp, $sp, 120 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_24_ + beq $t1 $zero _eq_false_24_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_24 + li $a2 5 + beq $a0 $a2 _eq_int_bool_24 + li $a2 6 + bne $a0 $a2 _not_basic_type_24_ +_eq_str_24_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_24_ + beq $t3 $0 _eq_true_24_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_24_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_24_ + b _eq_true_24_ +_not_basic_type_24_: + bne $t0 $t1 _eq_false_24_ + b _eq_true_24_ +_eq_int_bool_24: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_24_ +_eq_true_24_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_24_ +_eq_false_24_: + li $a0 0 + sw $a0 -8($fp) +end_equal_24_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_49 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # < + lw $a1, -32($fp) + lw $a2, -36($fp) + slt $a0, $a1, $a2 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_51 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_15 + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # - + li $a0 0 + lw $a1, -88($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # * + lw $a0, -76($fp) + lw $a1, -80($fp) + mul $a0, $a0, $a1 + sw $a0, -72($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_52 + +_cil_label_LABEL_51: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_52: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_50 + +_cil_label_LABEL_49: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_50: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_A2I_i2a_aux: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_25_ + beq $t1 $zero _eq_false_25_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_25 + li $a2 5 + beq $a0 $a2 _eq_int_bool_25 + li $a2 6 + bne $a0 $a2 _not_basic_type_25_ +_eq_str_25_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_25_ + beq $t3 $0 _eq_true_25_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_25_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_25_ + b _eq_true_25_ +_not_basic_type_25_: + bne $t0 $t1 _eq_false_25_ + b _eq_true_25_ +_eq_int_bool_25: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_25_ +_eq_true_25_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_25_ +_eq_false_25_: + li $a0 0 + sw $a0 -8($fp) +end_equal_25_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_53 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # / + lw $a0, -24($fp) + lw $a1, -28($fp) + beqz $a1 _div_error_26_ + div $a0, $a0, $a1 + sw $a0, -20($fp) + b _div_end_26_ +_div_error_26_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_26_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # * + lw $a0, -84($fp) + lw $a1, -88($fp) + mul $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_54 + +_cil_label_LABEL_53: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_54: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/atoi.s b/tests/codegen/atoi.s new file mode 100644 index 00000000..a6452e38 --- /dev/null +++ b/tests/codegen/atoi.s @@ -0,0 +1,7469 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "678987" + data_2: .align 2 + .asciiz " == " + data_3: .align 2 + .asciiz "\n" + data_4: .align 2 + .asciiz "0" + data_5: .align 2 + .asciiz "1" + data_6: .align 2 + .asciiz "2" + data_7: .align 2 + .asciiz "3" + data_8: .align 2 + .asciiz "4" + data_9: .align 2 + .asciiz "5" + data_10: .align 2 + .asciiz "6" + data_11: .align 2 + .asciiz "7" + data_12: .align 2 + .asciiz "8" + data_13: .align 2 + .asciiz "9" + data_14: .align 2 + .asciiz "-" + data_15: .align 2 + .asciiz "+" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_A2I: .align 2 + .asciiz "A2I" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_A2I + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type A2I + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type A2I + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A2I_c2i + sw $t1 12($v0) + la $t1 function_A2I_i2c + sw $t1 16($v0) + la $t1 function_A2I_a2i + sw $t1 20($v0) + la $t1 function_A2I_a2i_aux + sw $t1 24($v0) + la $t1 function_A2I_i2a + sw $t1 28($v0) + la $t1 function_A2I_i2a_aux + sw $t1 32($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 6 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A2I__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 678987 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A2I__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_A2I_c2i: + move $fp, $sp + subu $sp, $sp, 292 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_5 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -32($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_6 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -56($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_7 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -80($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -80($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_8 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -104($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -104($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_9 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -128($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -160($fp) + la $a0, data_10 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -160($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_7 + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 -152($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 -152($fp) +end_equal_7_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -148($fp) + + # IF GOTO + lw $a0, -148($fp) + bnez $a0, _cil_label_LABEL_12 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_11 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -184($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_8 + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -176($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -176($fp) +end_equal_8_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # IF GOTO + lw $a0, -172($fp) + bnez $a0, _cil_label_LABEL_14 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_12 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -208($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_9 + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -200($fp) +end_equal_9_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_16 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_13 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_10 + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -224($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -224($fp) +end_equal_10_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -228($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # IF GOTO + lw $a0, -220($fp) + bnez $a0, _cil_label_LABEL_18 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -240($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -240($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + lw $a2, -240($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -216($fp) + + # GOTO + j _cil_label_LABEL_19 + +_cil_label_LABEL_18: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 9 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -252($fp) + sw $a0, -216($fp) + +_cil_label_LABEL_19: + # ASSIGN + lw $a0, -216($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + li $a0, 8 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_17: + # ASSIGN + lw $a0, -192($fp) + sw $a0, -168($fp) + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_14: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 7 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -260($fp) + sw $a0, -168($fp) + +_cil_label_LABEL_15: + # ASSIGN + lw $a0, -168($fp) + sw $a0, -144($fp) + + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_12: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + li $a0, 6 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -144($fp) + +_cil_label_LABEL_13: + # ASSIGN + lw $a0, -144($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 5 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -268($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_11: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -96($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 4 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -96($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -96($fp) + sw $a0, -72($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 3 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -276($fp) + sw $a0, -72($fp) + +_cil_label_LABEL_7: + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + li $a0, 2 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -284($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 292 + jr $ra + +function_A2I_i2c: + move $fp, $sp + subu $sp, $sp, 296 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_11 + li $a2 5 + beq $a0 $a2 _eq_int_bool_11 + li $a2 6 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -8($fp) +end_equal_11_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_20 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -36($fp) + beq $t0 $zero _eq_false_12_ + beq $t1 $zero _eq_false_12_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_12 + li $a2 5 + beq $a0 $a2 _eq_int_bool_12 + li $a2 6 + bne $a0 $a2 _not_basic_type_12_ +_eq_str_12_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_12_ + beq $t3 $0 _eq_true_12_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_12_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_12_ + b _eq_true_12_ +_not_basic_type_12_: + bne $t0 $t1 _eq_false_12_ + b _eq_true_12_ +_eq_int_bool_12: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_12_ +_eq_true_12_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_12_ +_eq_false_12_: + li $a0 0 + sw $a0 -28($fp) +end_equal_12_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_22 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_13 + li $a2 5 + beq $a0 $a2 _eq_int_bool_13 + li $a2 6 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -48($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -48($fp) +end_equal_13_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_24 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_14_ + beq $t1 $zero _eq_false_14_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_14 + li $a2 5 + beq $a0 $a2 _eq_int_bool_14 + li $a2 6 + bne $a0 $a2 _not_basic_type_14_ +_eq_str_14_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_14_ + beq $t3 $0 _eq_true_14_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_14_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_14_ + b _eq_true_14_ +_not_basic_type_14_: + bne $t0 $t1 _eq_false_14_ + b _eq_true_14_ +_eq_int_bool_14: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_14_ +_eq_true_14_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_14_ +_eq_false_14_: + li $a0 0 + sw $a0 -68($fp) +end_equal_14_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_26 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 4 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -96($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_15 + li $a2 5 + beq $a0 $a2 _eq_int_bool_15 + li $a2 6 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -88($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -88($fp) +end_equal_15_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_28 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 5 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -116($fp) + beq $t0 $zero _eq_false_16_ + beq $t1 $zero _eq_false_16_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_16 + li $a2 5 + beq $a0 $a2 _eq_int_bool_16 + li $a2 6 + bne $a0 $a2 _not_basic_type_16_ +_eq_str_16_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_16_ + beq $t3 $0 _eq_true_16_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_16_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_16_ + b _eq_true_16_ +_not_basic_type_16_: + bne $t0 $t1 _eq_false_16_ + b _eq_true_16_ +_eq_int_bool_16: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_16_ +_eq_true_16_: + li $a0 1 + sw $a0 -108($fp) + b end_equal_16_ +_eq_false_16_: + li $a0 0 + sw $a0 -108($fp) +end_equal_16_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # IF GOTO + lw $a0, -104($fp) + bnez $a0, _cil_label_LABEL_30 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 6 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_17 + li $a2 5 + beq $a0 $a2 _eq_int_bool_17 + li $a2 6 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -128($fp) +end_equal_17_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_32 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 7 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -156($fp) + beq $t0 $zero _eq_false_18_ + beq $t1 $zero _eq_false_18_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_18 + li $a2 5 + beq $a0 $a2 _eq_int_bool_18 + li $a2 6 + bne $a0 $a2 _not_basic_type_18_ +_eq_str_18_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_18_ + beq $t3 $0 _eq_true_18_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_18_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_18_ + b _eq_true_18_ +_not_basic_type_18_: + bne $t0 $t1 _eq_false_18_ + b _eq_true_18_ +_eq_int_bool_18: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_18_ +_eq_true_18_: + li $a0 1 + sw $a0 -148($fp) + b end_equal_18_ +_eq_false_18_: + li $a0 0 + sw $a0 -148($fp) +end_equal_18_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -144($fp) + + # IF GOTO + lw $a0, -144($fp) + bnez $a0, _cil_label_LABEL_34 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 8 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_19 + li $a2 5 + beq $a0 $a2 _eq_int_bool_19 + li $a2 6 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -168($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -168($fp) +end_equal_19_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # IF GOTO + lw $a0, -164($fp) + bnez $a0, _cil_label_LABEL_36 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + li $a0, 9 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -196($fp) + beq $t0 $zero _eq_false_20_ + beq $t1 $zero _eq_false_20_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_20 + li $a2 5 + beq $a0 $a2 _eq_int_bool_20 + li $a2 6 + bne $a0 $a2 _not_basic_type_20_ +_eq_str_20_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_20_ + beq $t3 $0 _eq_true_20_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_20_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_20_ + b _eq_true_20_ +_not_basic_type_20_: + bne $t0 $t1 _eq_false_20_ + b _eq_true_20_ +_eq_int_bool_20: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_20_ +_eq_true_20_: + li $a0 1 + sw $a0 -188($fp) + b end_equal_20_ +_eq_false_20_: + li $a0 0 + sw $a0 -188($fp) +end_equal_20_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -192($fp) + lw $a0 12($a1) + sw $a0 -184($fp) + + # IF GOTO + lw $a0, -184($fp) + bnez $a0, _cil_label_LABEL_38 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -200($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -200($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + lw $a2, -200($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -208($fp) + sw $a0, -180($fp) + + # GOTO + j _cil_label_LABEL_39 + +_cil_label_LABEL_38: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -216($fp) + la $a0, data_13 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -216($fp) + sw $a0, -180($fp) + +_cil_label_LABEL_39: + # ASSIGN + lw $a0, -180($fp) + sw $a0, -160($fp) + + # GOTO + j _cil_label_LABEL_37 + +_cil_label_LABEL_36: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + lw $a0 -228($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -224($fp) + la $a0, data_12 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, -160($fp) + +_cil_label_LABEL_37: + # ASSIGN + lw $a0, -160($fp) + sw $a0, -140($fp) + + # GOTO + j _cil_label_LABEL_35 + +_cil_label_LABEL_34: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_11 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -232($fp) + sw $a0, -140($fp) + +_cil_label_LABEL_35: + # ASSIGN + lw $a0, -140($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_33 + +_cil_label_LABEL_32: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -244($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -240($fp) + la $a0, data_10 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -240($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_33: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -100($fp) + + # GOTO + j _cil_label_LABEL_31 + +_cil_label_LABEL_30: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + lw $a0 -252($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -248($fp) + la $a0, data_9 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -248($fp) + sw $a0, -100($fp) + +_cil_label_LABEL_31: + # ASSIGN + lw $a0, -100($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_29 + +_cil_label_LABEL_28: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_8 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -256($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_29: + # ASSIGN + lw $a0, -80($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_27 + +_cil_label_LABEL_26: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + lw $a0 -268($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -264($fp) + la $a0, data_7 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_27: + # ASSIGN + lw $a0, -60($fp) + sw $a0, -40($fp) + + # GOTO + j _cil_label_LABEL_25 + +_cil_label_LABEL_24: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -276($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -272($fp) + la $a0, data_6 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -40($fp) + +_cil_label_LABEL_25: + # ASSIGN + lw $a0, -40($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_23 + +_cil_label_LABEL_22: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + lw $a0 -284($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -280($fp) + la $a0, data_5 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_23: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_21 + +_cil_label_LABEL_20: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + lw $a0 -292($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -288($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_21: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 296 + jr $ra + +function_A2I_a2i: + move $fp, $sp + subu $sp, $sp, 228 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_21_ + beq $t1 $zero _eq_false_21_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_21 + li $a2 5 + beq $a0 $a2 _eq_int_bool_21 + li $a2 6 + bne $a0 $a2 _not_basic_type_21_ +_eq_str_21_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_21_ + beq $t3 $0 _eq_true_21_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_21_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_21_ + b _eq_true_21_ +_not_basic_type_21_: + bne $t0 $t1 _eq_false_21_ + b _eq_true_21_ +_eq_int_bool_21: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_21_ +_eq_true_21_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_21_ +_eq_false_21_: + li $a0 0 + sw $a0 -8($fp) +end_equal_21_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_40 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_14 + sw $a0 16($a1) + + lw $t0 -48($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_22_ + beq $t1 $zero _eq_false_22_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_22 + li $a2 5 + beq $a0 $a2 _eq_int_bool_22 + li $a2 6 + bne $a0 $a2 _not_basic_type_22_ +_eq_str_22_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_22_ + beq $t3 $0 _eq_true_22_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_22_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_22_ + b _eq_true_22_ +_not_basic_type_22_: + bne $t0 $t1 _eq_false_22_ + b _eq_true_22_ +_eq_int_bool_22: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_22_ +_eq_true_22_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_22_ +_eq_false_22_: + li $a0 0 + sw $a0 -36($fp) +end_equal_22_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_42 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_15 + sw $a0 16($a1) + + lw $t0 -88($fp) + lw $t1 -100($fp) + beq $t0 $zero _eq_false_23_ + beq $t1 $zero _eq_false_23_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_23 + li $a2 5 + beq $a0 $a2 _eq_int_bool_23 + li $a2 6 + bne $a0 $a2 _not_basic_type_23_ +_eq_str_23_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_23_ + beq $t3 $0 _eq_true_23_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_23_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_23_ + b _eq_true_23_ +_not_basic_type_23_: + bne $t0 $t1 _eq_false_23_ + b _eq_true_23_ +_eq_int_bool_23: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_23_ +_eq_true_23_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_23_ +_eq_false_23_: + li $a0 0 + sw $a0 -76($fp) +end_equal_23_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_44 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_45 + +_cil_label_LABEL_44: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -140($fp) + + # - + lw $a0, -136($fp) + lw $a1, -140($fp) + sub $a0, $a0, $a1 + sw $a0, -132($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -132($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -128($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_45: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_43 + +_cil_label_LABEL_42: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -212($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # GETATTR + lw $a1 -216($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # - + lw $a0, -196($fp) + lw $a1, -200($fp) + sub $a0, $a0, $a1 + sw $a0, -192($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -184($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -184($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + lw $a2, -184($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # - + li $a0 0 + lw $a1, -164($fp) + sub $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_43: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_41 + +_cil_label_LABEL_40: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_41: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 228 + jr $ra + +function_A2I_a2i_aux: + move $fp, $sp + subu $sp, $sp, 116 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_46: + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_47 + + # GOTO + j _cil_label_LABEL_48 + +_cil_label_LABEL_47: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # * + lw $a0, -60($fp) + lw $a1, -64($fp) + mul $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # + + lw $a0, -44($fp) + lw $a1, -48($fp) + add $a0, $a0, $a1 + sw $a0, -40($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_48: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 116 + jr $ra + +function_A2I_i2a: + move $fp, $sp + subu $sp, $sp, 120 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_24_ + beq $t1 $zero _eq_false_24_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_24 + li $a2 5 + beq $a0 $a2 _eq_int_bool_24 + li $a2 6 + bne $a0 $a2 _not_basic_type_24_ +_eq_str_24_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_24_ + beq $t3 $0 _eq_true_24_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_24_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_24_ + b _eq_true_24_ +_not_basic_type_24_: + bne $t0 $t1 _eq_false_24_ + b _eq_true_24_ +_eq_int_bool_24: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_24_ +_eq_true_24_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_24_ +_eq_false_24_: + li $a0 0 + sw $a0 -8($fp) +end_equal_24_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_49 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # < + lw $a1, -32($fp) + lw $a2, -36($fp) + slt $a0, $a1, $a2 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_51 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_14 + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # - + li $a0 0 + lw $a1, -88($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # * + lw $a0, -76($fp) + lw $a1, -80($fp) + mul $a0, $a0, $a1 + sw $a0, -72($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_52 + +_cil_label_LABEL_51: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_52: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_50 + +_cil_label_LABEL_49: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_50: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_A2I_i2a_aux: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_25_ + beq $t1 $zero _eq_false_25_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_25 + li $a2 5 + beq $a0 $a2 _eq_int_bool_25 + li $a2 6 + bne $a0 $a2 _not_basic_type_25_ +_eq_str_25_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_25_ + beq $t3 $0 _eq_true_25_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_25_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_25_ + b _eq_true_25_ +_not_basic_type_25_: + bne $t0 $t1 _eq_false_25_ + b _eq_true_25_ +_eq_int_bool_25: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_25_ +_eq_true_25_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_25_ +_eq_false_25_: + li $a0 0 + sw $a0 -8($fp) +end_equal_25_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_53 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # / + lw $a0, -24($fp) + lw $a1, -28($fp) + beqz $a1 _div_error_26_ + div $a0, $a0, $a1 + sw $a0, -20($fp) + b _div_end_26_ +_div_error_26_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_26_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # * + lw $a0, -84($fp) + lw $a1, -88($fp) + mul $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # - + lw $a0, -68($fp) + lw $a1, -72($fp) + sub $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_54 + +_cil_label_LABEL_53: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_54: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/book_list.mips b/tests/codegen/book_list.mips new file mode 100644 index 00000000..8eaec30c --- /dev/null +++ b/tests/codegen/book_list.mips @@ -0,0 +1,4157 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "title: " + data_2: .align 2 + .asciiz "\n" + data_3: .align 2 + .asciiz "author: " + data_4: .align 2 + .asciiz "periodical: " + data_5: .align 2 + .asciiz "Abort called from class BookList\n" + data_6: .align 2 + .asciiz "- dynamic type was Article -\n" + data_7: .align 2 + .asciiz "- dynamic type was Book -\n" + data_8: .align 2 + .asciiz "Aho, Sethi, and Ullman" + data_9: .align 2 + .asciiz "Compilers, Principles, Techniques, and Tools" + data_10: .align 2 + .asciiz "PC Magazine" + data_11: .align 2 + .asciiz "Ulanoff" + data_12: .align 2 + .asciiz "The Top 100 CD_ROMs" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Book: .align 2 + .asciiz "Book" + classname_Article: .align 2 + .asciiz "Article" + classname_BookList: .align 2 + .asciiz "BookList" + classname_Cons: .align 2 + .asciiz "Cons" + classname_Nil: .align 2 + .asciiz "Nil" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Main: .align 2 + .asciiz "Main" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 48 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Book + sw $t1 12($s1) + la $t1 classname_Article + sw $t1 16($s1) + la $t1 classname_BookList + sw $t1 20($s1) + la $t1 classname_Cons + sw $t1 24($s1) + la $t1 classname_Nil + sw $t1 28($s1) + la $t1 classname_Int + sw $t1 32($s1) + la $t1 classname_Bool + sw $t1 36($s1) + la $t1 classname_String + sw $t1 40($s1) + la $t1 classname_Main + sw $t1 44($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 96 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Book + li $a0 20 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Article + li $a0 24 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type BookList + li $a0 12 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Nil + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 80($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 11 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 88($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Book + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Book_initBook + sw $t1 28($v0) + la $t1 function_Book_print + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Article + li $a0 40 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Book_initBook + sw $t1 28($v0) + la $t1 function_Article_print + sw $t1 32($v0) + la $t1 function_Article_initArticle + sw $t1 36($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type BookList + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_BookList_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_BookList_car + sw $t1 36($v0) + la $t1 function_BookList_cdr + sw $t1 40($v0) + la $t1 function_BookList_print_list + sw $t1 44($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 52 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Cons_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_Cons_car + sw $t1 36($v0) + la $t1 function_Cons_cdr + sw $t1 40($v0) + la $t1 function_Cons_print_list + sw $t1 44($v0) + la $t1 function_Cons_init + sw $t1 48($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Nil + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Nil_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_BookList_car + sw $t1 36($v0) + la $t1 function_BookList_cdr + sw $t1 40($v0) + la $t1 function_Nil_print_list + sw $t1 44($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Main_main + sw $t1 12($v0) + lw $t0 88($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 48 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 11 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Book__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Book_initBook: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Book_print: + move $fp, $sp + subu $sp, $sp, 88 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -4($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -64($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 88 + jr $ra + +function_Article__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Article_initArticle: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 24($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Article_print: + move $fp, $sp + subu $sp, $sp, 48 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 3 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + li $a2, 3 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 13 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 48 + jr $ra + +function_BookList__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_BookList_isNil: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 33 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_BookList_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_BookList_car: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 33 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 40 + jr $ra + +function_BookList_cdr: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 33 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 40 + jr $ra + +function_BookList_print_list: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 33 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Cons_car: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_cdr: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_print_list: + move $fp, $sp + subu $sp, $sp, 68 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 4 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + li $a0, 3 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -32($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -28($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_7 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -44($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -56($fp) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -64($fp) + addiu $sp, $sp, 68 + jr $ra + +function_Nil__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Nil_print_list: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_8 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 44 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_9 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Article__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_10 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -56($fp) + la $a0, data_11 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_12 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -32($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Nil__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -72($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -84($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -96($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -104($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/book_list.s b/tests/codegen/book_list.s new file mode 100644 index 00000000..f2237add --- /dev/null +++ b/tests/codegen/book_list.s @@ -0,0 +1,3796 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "title: " + data_2: .align 2 + .asciiz "\n" + data_3: .align 2 + .asciiz "author: " + data_4: .align 2 + .asciiz "periodical: " + data_5: .align 2 + .asciiz "- dynamic type was Article -\n" + data_6: .align 2 + .asciiz "- dynamic type was Book -\n" + data_7: .align 2 + .asciiz "Aho, Sethi, and Ullman" + data_8: .align 2 + .asciiz "Compilers, Principles, Techniques, and Tools" + data_9: .align 2 + .asciiz "PC Magazine" + data_10: .align 2 + .asciiz "Ulanoff" + data_11: .align 2 + .asciiz "The Top 100 CD_ROMs" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Book: .align 2 + .asciiz "Book" + classname_Article: .align 2 + .asciiz "Article" + classname_BookList: .align 2 + .asciiz "BookList" + classname_Cons: .align 2 + .asciiz "Cons" + classname_Nil: .align 2 + .asciiz "Nil" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Main: .align 2 + .asciiz "Main" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 48 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Book + sw $t1 12($s1) + la $t1 classname_Article + sw $t1 16($s1) + la $t1 classname_BookList + sw $t1 20($s1) + la $t1 classname_Cons + sw $t1 24($s1) + la $t1 classname_Nil + sw $t1 28($s1) + la $t1 classname_Int + sw $t1 32($s1) + la $t1 classname_Bool + sw $t1 36($s1) + la $t1 classname_String + sw $t1 40($s1) + la $t1 classname_Main + sw $t1 44($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 96 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Book + li $a0 20 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Article + li $a0 24 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type BookList + li $a0 12 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Nil + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 80($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 11 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 88($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Book + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Book_initBook + sw $t1 28($v0) + la $t1 function_Book_print + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Article + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Book_initBook + sw $t1 28($v0) + la $t1 function_Book_print + sw $t1 32($v0) + la $t1 function_Article_initArticle + sw $t1 36($v0) + la $t1 function_Article_print + sw $t1 40($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type BookList + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_BookList_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_BookList_car + sw $t1 36($v0) + la $t1 function_BookList_cdr + sw $t1 40($v0) + la $t1 function_BookList_print_list + sw $t1 44($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 68 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_BookList_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_BookList_car + sw $t1 36($v0) + la $t1 function_BookList_cdr + sw $t1 40($v0) + la $t1 function_BookList_print_list + sw $t1 44($v0) + la $t1 function_Cons_isNil + sw $t1 48($v0) + la $t1 function_Cons_init + sw $t1 52($v0) + la $t1 function_Cons_car + sw $t1 56($v0) + la $t1 function_Cons_cdr + sw $t1 60($v0) + la $t1 function_Cons_print_list + sw $t1 64($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Nil + li $a0 56 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_BookList_isNil + sw $t1 28($v0) + la $t1 function_BookList_cons + sw $t1 32($v0) + la $t1 function_BookList_car + sw $t1 36($v0) + la $t1 function_BookList_cdr + sw $t1 40($v0) + la $t1 function_BookList_print_list + sw $t1 44($v0) + la $t1 function_Nil_isNil + sw $t1 48($v0) + la $t1 function_Nil_print_list + sw $t1 52($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Main_main + sw $t1 12($v0) + lw $t0 88($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 48 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 11 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Book__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Book_initBook: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Book_print: + move $fp, $sp + subu $sp, $sp, 88 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -4($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -64($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 88 + jr $ra + +function_Article__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Article_initArticle: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 24($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Article_print: + move $fp, $sp + subu $sp, $sp, 48 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 3 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + li $a2, 3 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 13 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 48 + jr $ra + +function_BookList__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_BookList_isNil: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_BookList_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_BookList_car: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_BookList_cdr: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_BookList_print_list: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Cons_car: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_cdr: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_print_list: + move $fp, $sp + subu $sp, $sp, 68 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 4 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + li $a0, 3 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -32($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -28($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -44($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -56($fp) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -64($fp) + addiu $sp, $sp, 68 + jr $ra + +function_Nil__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BookList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Nil_print_list: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 108 + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Book__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_7 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 44 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_8 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Article__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_9 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 7 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -56($fp) + la $a0, data_10 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_11 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -32($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Nil__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -72($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -84($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -96($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -104($fp) + addiu $sp, $sp, 108 + jr $ra + + +##################################### + diff --git a/tests/codegen/cells.mips b/tests/codegen/cells.mips new file mode 100644 index 00000000..7729f2fd --- /dev/null +++ b/tests/codegen/cells.mips @@ -0,0 +1,3788 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + data_2: .align 2 + .asciiz "X" + data_3: .align 2 + .asciiz "." + data_4: .align 2 + .asciiz " X " + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_CellularAutomaton: .align 2 + .asciiz "CellularAutomaton" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Main: .align 2 + .asciiz "Main" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_CellularAutomaton + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_Main + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type CellularAutomaton + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type CellularAutomaton + li $a0 60 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_CellularAutomaton_init + sw $t1 28($v0) + la $t1 function_CellularAutomaton_print + sw $t1 32($v0) + la $t1 function_CellularAutomaton_num_cells + sw $t1 36($v0) + la $t1 function_CellularAutomaton_cell + sw $t1 40($v0) + la $t1 function_CellularAutomaton_cell_left_neighbor + sw $t1 44($v0) + la $t1 function_CellularAutomaton_cell_right_neighbor + sw $t1 48($v0) + la $t1 function_CellularAutomaton_cell_at_next_evolution + sw $t1 52($v0) + la $t1 function_CellularAutomaton_evolve + sw $t1 56($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Main_main + sw $t1 12($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_CellularAutomaton__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_CellularAutomaton_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_CellularAutomaton_print: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_CellularAutomaton_num_cells: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_CellularAutomaton_cell: + move $fp, $sp + subu $sp, $sp, 16 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_CellularAutomaton_cell_left_neighbor: + move $fp, $sp + subu $sp, $sp, 84 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # - + lw $a0, -32($fp) + lw $a1, -36($fp) + sub $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # - + lw $a0, -60($fp) + lw $a1, -64($fp) + sub $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_cell_right_neighbor: + move $fp, $sp + subu $sp, $sp, 84 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # - + lw $a0, -20($fp) + lw $a1, -24($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -28($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -8($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # + + lw $a0, -56($fp) + lw $a1, -60($fp) + add $a0, $a0, $a1 + sw $a0, -52($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_cell_at_next_evolution: + move $fp, $sp + subu $sp, $sp, 188 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -68($fp) + lw $t1 -72($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -56($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_7: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -108($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -96($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -96($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # IF GOTO + lw $a0, -92($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -88($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -124($fp) + sw $a0, -88($fp) + +_cil_label_LABEL_9: + # GETATTR + lw $a1 -48($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -88($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # + + lw $a0, -36($fp) + lw $a1, -40($fp) + add $a0, $a0, $a1 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -156($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -152($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -148($fp) + lw $t1 -152($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -136($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -136($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # IF GOTO + lw $a0, -132($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -160($fp) + sw $a0, -128($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -164($fp) + sw $a0, -128($fp) + +_cil_label_LABEL_11: + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # + + lw $a0, -20($fp) + lw $a1, -24($fp) + add $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -28($fp) + lw $t1 -168($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -8($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -172($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -184($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -180($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_5: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_CellularAutomaton_evolve: + move $fp, $sp + subu $sp, $sp, 76 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_12: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_13 + + # GOTO + j _cil_label_LABEL_14 + +_cil_label_LABEL_13: + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -44($fp) + sw $a0, -12($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_14: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 76 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 112 + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_CellularAutomaton__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 20 + sw $a0 12($a1) + +_cil_label_LABEL_15: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # < + lw $a1, -52($fp) + lw $a2, -56($fp) + slt $a0, $a1, $a2 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_16 + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -68($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -80($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # - + lw $a0, -96($fp) + lw $a1, -100($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -104($fp) + sw $a0, -36($fp) + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_17: + # ALLOCATE + la $v0 type_void + sw $v0 -40($fp) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 112 + jr $ra + + +##################################### + diff --git a/tests/codegen/cells.s b/tests/codegen/cells.s new file mode 100644 index 00000000..25bb8de3 --- /dev/null +++ b/tests/codegen/cells.s @@ -0,0 +1,3784 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + data_2: .align 2 + .asciiz "X" + data_3: .align 2 + .asciiz "." + data_4: .align 2 + .asciiz " X " + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_CellularAutomaton: .align 2 + .asciiz "CellularAutomaton" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Main: .align 2 + .asciiz "Main" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_CellularAutomaton + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_Main + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type CellularAutomaton + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type CellularAutomaton + li $a0 60 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_CellularAutomaton_init + sw $t1 28($v0) + la $t1 function_CellularAutomaton_print + sw $t1 32($v0) + la $t1 function_CellularAutomaton_num_cells + sw $t1 36($v0) + la $t1 function_CellularAutomaton_cell + sw $t1 40($v0) + la $t1 function_CellularAutomaton_cell_left_neighbor + sw $t1 44($v0) + la $t1 function_CellularAutomaton_cell_right_neighbor + sw $t1 48($v0) + la $t1 function_CellularAutomaton_cell_at_next_evolution + sw $t1 52($v0) + la $t1 function_CellularAutomaton_evolve + sw $t1 56($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Main_main + sw $t1 12($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_CellularAutomaton__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_CellularAutomaton_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_CellularAutomaton_print: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_CellularAutomaton_num_cells: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_CellularAutomaton_cell: + move $fp, $sp + subu $sp, $sp, 16 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_CellularAutomaton_cell_left_neighbor: + move $fp, $sp + subu $sp, $sp, 84 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # - + lw $a0, -32($fp) + lw $a1, -36($fp) + sub $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # - + lw $a0, -60($fp) + lw $a1, -64($fp) + sub $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_cell_right_neighbor: + move $fp, $sp + subu $sp, $sp, 84 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # - + lw $a0, -20($fp) + lw $a1, -24($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -28($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -8($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # + + lw $a0, -56($fp) + lw $a1, -60($fp) + add $a0, $a0, $a1 + sw $a0, -52($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_cell_at_next_evolution: + move $fp, $sp + subu $sp, $sp, 188 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -68($fp) + lw $t1 -72($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -56($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_7: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -108($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_4 + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -96($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -96($fp) +end_equal_4_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # IF GOTO + lw $a0, -92($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -88($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -124($fp) + sw $a0, -88($fp) + +_cil_label_LABEL_9: + # GETATTR + lw $a1 -48($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -88($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # + + lw $a0, -36($fp) + lw $a1, -40($fp) + add $a0, $a0, $a1 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -156($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -152($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -148($fp) + lw $t1 -152($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_5 + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -136($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -136($fp) +end_equal_5_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # IF GOTO + lw $a0, -132($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -160($fp) + sw $a0, -128($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -164($fp) + sw $a0, -128($fp) + +_cil_label_LABEL_11: + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # + + lw $a0, -20($fp) + lw $a1, -24($fp) + add $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -28($fp) + lw $t1 -168($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_6 + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -8($fp) +end_equal_6_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -172($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -184($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -180($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_5: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_CellularAutomaton_evolve: + move $fp, $sp + subu $sp, $sp, 76 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_12: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_13 + + # GOTO + j _cil_label_LABEL_14 + +_cil_label_LABEL_13: + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -44($fp) + sw $a0, -12($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_14: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 76 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 112 + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_CellularAutomaton__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 19 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 20 + sw $a0 12($a1) + +_cil_label_LABEL_15: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # < + lw $a1, -52($fp) + lw $a2, -56($fp) + slt $a0, $a1, $a2 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_16 + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -68($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -80($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # - + lw $a0, -96($fp) + lw $a1, -100($fp) + sub $a0, $a0, $a1 + sw $a0, -92($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -104($fp) + sw $a0, -36($fp) + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_17: + # ALLOCATE + la $v0 type_void + sw $v0 -40($fp) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 112 + jr $ra + + +##################################### + diff --git a/tests/codegen/complex.mips b/tests/codegen/complex.mips new file mode 100644 index 00000000..9dea8b85 --- /dev/null +++ b/tests/codegen/complex.mips @@ -0,0 +1,2715 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "=(\n" + data_2: .align 2 + .asciiz "=)\n" + data_3: .align 2 + .asciiz "+" + data_4: .align 2 + .asciiz "I" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Complex: .align 2 + .asciiz "Complex" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Complex + sw $t1 16($s1) + la $t1 classname_Int + sw $t1 20($s1) + la $t1 classname_Bool + sw $t1 24($s1) + la $t1 classname_String + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Complex + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Complex + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Complex_init + sw $t1 28($v0) + la $t1 function_Complex_print + sw $t1 32($v0) + la $t1 function_Complex_reflect_0 + sw $t1 36($v0) + la $t1 function_Complex_reflect_X + sw $t1 40($v0) + la $t1 function_Complex_reflect_Y + sw $t1 44($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 96 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Complex__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -52($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + beq $a0 $a2 _eq_int_bool_1 + li $a2 7 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, -24($fp) + addiu $sp, $sp, 96 + jr $ra + +function_Complex__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Complex_init: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + lw $t0 -8($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + beq $a0 $a2 _eq_int_bool_2 + li $a2 7 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 0($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 0($fp) +end_equal_2_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -20($fp) + + lw $t0 -20($fp) + lw $t1 20($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + beq $a0 $a2 _eq_int_bool_3 + li $a2 7 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -12($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -12($fp) +end_equal_3_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Complex_print: + move $fp, $sp + subu $sp, $sp, 92 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -16($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + beq $a0 $a2 _eq_int_bool_4 + li $a2 7 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -8($fp) +end_equal_4_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_2 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -40($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Complex_reflect_0: + move $fp, $sp + subu $sp, $sp, 56 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + beq $a0 $a2 _eq_int_bool_5 + li $a2 7 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 0($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 0($fp) +end_equal_5_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # - + li $a0 0 + lw $a1, -40($fp) + sub $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + lw $t0 -36($fp) + lw $t1 -48($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + beq $a0 $a2 _eq_int_bool_6 + li $a2 7 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -28($fp) +end_equal_6_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Complex_reflect_X: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + beq $a0 $a2 _eq_int_bool_7 + li $a2 7 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 0($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 0($fp) +end_equal_7_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_reflect_Y: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + beq $a0 $a2 _eq_int_bool_8 + li $a2 7 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 0($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 0($fp) +end_equal_8_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/complex.s b/tests/codegen/complex.s new file mode 100644 index 00000000..9820cd11 --- /dev/null +++ b/tests/codegen/complex.s @@ -0,0 +1,2728 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "=(\n" + data_2: .align 2 + .asciiz "=)\n" + data_3: .align 2 + .asciiz "+" + data_4: .align 2 + .asciiz "I" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Complex: .align 2 + .asciiz "Complex" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Complex + sw $t1 16($s1) + la $t1 classname_Int + sw $t1 20($s1) + la $t1 classname_Bool + sw $t1 24($s1) + la $t1 classname_String + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Complex + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Complex + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Complex_init + sw $t1 28($v0) + la $t1 function_Complex_print + sw $t1 32($v0) + la $t1 function_Complex_reflect_0 + sw $t1 36($v0) + la $t1 function_Complex_reflect_X + sw $t1 40($v0) + la $t1 function_Complex_reflect_Y + sw $t1 44($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 96 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Complex__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -52($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + beq $a0 $a2 _eq_int_bool_1 + li $a2 7 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, -24($fp) + addiu $sp, $sp, 96 + jr $ra + +function_Complex__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Complex_init: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + lw $t0 -8($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + beq $a0 $a2 _eq_int_bool_2 + li $a2 7 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 0($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 0($fp) +end_equal_2_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -20($fp) + + lw $t0 -20($fp) + lw $t1 20($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + beq $a0 $a2 _eq_int_bool_3 + li $a2 7 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -12($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -12($fp) +end_equal_3_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Complex_print: + move $fp, $sp + subu $sp, $sp, 92 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -16($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + beq $a0 $a2 _eq_int_bool_4 + li $a2 7 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -8($fp) +end_equal_4_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_2 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -40($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Complex_reflect_0: + move $fp, $sp + subu $sp, $sp, 56 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + beq $a0 $a2 _eq_int_bool_5 + li $a2 7 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 0($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 0($fp) +end_equal_5_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # - + li $a0 0 + lw $a1, -40($fp) + sub $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + lw $t0 -36($fp) + lw $t1 -48($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + beq $a0 $a2 _eq_int_bool_6 + li $a2 7 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -28($fp) +end_equal_6_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Complex_reflect_X: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + beq $a0 $a2 _eq_int_bool_7 + li $a2 7 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 0($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 0($fp) +end_equal_7_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_reflect_Y: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + beq $a0 $a2 _eq_int_bool_8 + li $a2 7 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 0($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 0($fp) +end_equal_8_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/fib.mips b/tests/codegen/fib.mips new file mode 100644 index 00000000..3b52019d --- /dev/null +++ b/tests/codegen/fib.mips @@ -0,0 +1,1620 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "Enter n to find nth fibonacci number!\n" + data_2: .align 2 + .asciiz "\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + la $t1 function_Main_fib + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 56 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 38 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -44($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Main_fib: + move $fp, $sp + subu $sp, $sp, 80 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # - + li $a0 1 + lw $a1, -20($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -28($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # IF GOTO + lw $a0, -16($fp) + bnez $a0, _cil_label_LABEL_1 + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # + + lw $a0, -48($fp) + lw $a1, -52($fp) + add $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -56($fp) + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # - + lw $a0, -64($fp) + lw $a1, -68($fp) + sub $a0, $a0, $a1 + sw $a0, -60($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -72($fp) + sw $a0, 16($fp) + + # ASSIGN + lw $a0, 0($fp) + sw $a0, -4($fp) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_0 + +_cil_label_LABEL_2: + # ALLOCATE + la $v0 type_void + sw $v0 -12($fp) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/fib.s b/tests/codegen/fib.s new file mode 100644 index 00000000..9517eeee --- /dev/null +++ b/tests/codegen/fib.s @@ -0,0 +1,1616 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "Enter n to find nth fibonacci number!\n" + data_2: .align 2 + .asciiz "\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + la $t1 function_Main_fib + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 56 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 38 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -48($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -44($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Main_fib: + move $fp, $sp + subu $sp, $sp, 80 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # - + li $a0 1 + lw $a1, -20($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -28($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # IF GOTO + lw $a0, -16($fp) + bnez $a0, _cil_label_LABEL_1 + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # + + lw $a0, -48($fp) + lw $a1, -52($fp) + add $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -56($fp) + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # - + lw $a0, -64($fp) + lw $a1, -68($fp) + sub $a0, $a0, $a1 + sw $a0, -60($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -72($fp) + sw $a0, 16($fp) + + # ASSIGN + lw $a0, 0($fp) + sw $a0, -4($fp) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_0 + +_cil_label_LABEL_2: + # ALLOCATE + la $v0 type_void + sw $v0 -12($fp) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/graph.mips b/tests/codegen/graph.mips new file mode 100644 index 00000000..1287847d --- /dev/null +++ b/tests/codegen/graph.mips @@ -0,0 +1,10190 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz " (" + data_2: .align 2 + .asciiz "," + data_3: .align 2 + .asciiz ")" + data_4: .align 2 + .asciiz "Abort called from class EList\n" + data_5: .align 2 + .asciiz "\n" + data_6: .align 2 + .asciiz "Abort called from class VList\n" + data_7: .align 2 + .asciiz "0" + data_8: .align 2 + .asciiz "1" + data_9: .align 2 + .asciiz "2" + data_10: .align 2 + .asciiz "3" + data_11: .align 2 + .asciiz "4" + data_12: .align 2 + .asciiz "5" + data_13: .align 2 + .asciiz "6" + data_14: .align 2 + .asciiz "7" + data_15: .align 2 + .asciiz "8" + data_16: .align 2 + .asciiz "9" + data_17: .align 2 + .asciiz "Abort called from class Parse\n" + data_18: .align 2 + .asciiz "-" + data_19: .align 2 + .asciiz " " + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Vertice: .align 2 + .asciiz "Vertice" + classname_Edge: .align 2 + .asciiz "Edge" + classname_EList: .align 2 + .asciiz "EList" + classname_ECons: .align 2 + .asciiz "ECons" + classname_VList: .align 2 + .asciiz "VList" + classname_VCons: .align 2 + .asciiz "VCons" + classname_Parse: .align 2 + .asciiz "Parse" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Graph: .align 2 + .asciiz "Graph" + classname_BoolOp: .align 2 + .asciiz "BoolOp" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 64 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Vertice + sw $t1 12($s1) + la $t1 classname_Edge + sw $t1 16($s1) + la $t1 classname_EList + sw $t1 20($s1) + la $t1 classname_ECons + sw $t1 24($s1) + la $t1 classname_VList + sw $t1 28($s1) + la $t1 classname_VCons + sw $t1 32($s1) + la $t1 classname_Parse + sw $t1 36($s1) + la $t1 classname_Main + sw $t1 40($s1) + la $t1 classname_Int + sw $t1 44($s1) + la $t1 classname_Bool + sw $t1 48($s1) + la $t1 classname_String + sw $t1 52($s1) + la $t1 classname_Graph + sw $t1 56($s1) + la $t1 classname_BoolOp + sw $t1 60($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 128 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Vertice + li $a0 20 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Edge + li $a0 24 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type EList + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type ECons + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type VList + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type VCons + li $a0 20 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type Parse + li $a0 20 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type Main + li $a0 24 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 80($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 11 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 88($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 12 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 96($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 13 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 104($s0) + + # Type Graph + li $a0 20 + li $v0 9 + syscall + li $a0 14 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 112($s0) + + # Type BoolOp + li $a0 12 + li $v0 9 + syscall + li $a0 15 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 120($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Vertice + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Vertice_outgoing + sw $t1 28($v0) + la $t1 function_Vertice_number + sw $t1 32($v0) + la $t1 function_Vertice_init + sw $t1 36($v0) + la $t1 function_Vertice_add_out + sw $t1 40($v0) + la $t1 function_Vertice_print + sw $t1 44($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Edge + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Edge_init + sw $t1 28($v0) + la $t1 function_Edge_print + sw $t1 32($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type EList + li $a0 52 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_EList_isNil + sw $t1 28($v0) + la $t1 function_EList_head + sw $t1 32($v0) + la $t1 function_EList_tail + sw $t1 36($v0) + la $t1 function_EList_cons + sw $t1 40($v0) + la $t1 function_EList_append + sw $t1 44($v0) + la $t1 function_EList_print + sw $t1 48($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type ECons + li $a0 56 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_ECons_isNil + sw $t1 28($v0) + la $t1 function_ECons_head + sw $t1 32($v0) + la $t1 function_ECons_tail + sw $t1 36($v0) + la $t1 function_EList_cons + sw $t1 40($v0) + la $t1 function_EList_append + sw $t1 44($v0) + la $t1 function_ECons_print + sw $t1 48($v0) + la $t1 function_ECons_init + sw $t1 52($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type VList + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_VList_isNil + sw $t1 28($v0) + la $t1 function_VList_head + sw $t1 32($v0) + la $t1 function_VList_tail + sw $t1 36($v0) + la $t1 function_VList_cons + sw $t1 40($v0) + la $t1 function_VList_print + sw $t1 44($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type VCons + li $a0 52 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_VCons_isNil + sw $t1 28($v0) + la $t1 function_VCons_head + sw $t1 32($v0) + la $t1 function_VCons_tail + sw $t1 36($v0) + la $t1 function_VList_cons + sw $t1 40($v0) + la $t1 function_VCons_print + sw $t1 44($v0) + la $t1 function_VCons_init + sw $t1 48($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type Parse + li $a0 48 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Parse_read_input + sw $t1 28($v0) + la $t1 function_Parse_parse_line + sw $t1 32($v0) + la $t1 function_Parse_c2i + sw $t1 36($v0) + la $t1 function_Parse_a2i + sw $t1 40($v0) + la $t1 function_Parse_a2i_aux + sw $t1 44($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type Main + li $a0 52 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Parse_read_input + sw $t1 28($v0) + la $t1 function_Parse_parse_line + sw $t1 32($v0) + la $t1 function_Parse_c2i + sw $t1 36($v0) + la $t1 function_Parse_a2i + sw $t1 40($v0) + la $t1 function_Parse_a2i_aux + sw $t1 44($v0) + la $t1 function_Main_main + sw $t1 48($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 88($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 96($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 104($s0) + sw $v0 8($t0) + + # Type Graph + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Graph_add_vertice + sw $t1 12($v0) + la $t1 function_Graph_print_E + sw $t1 16($v0) + la $t1 function_Graph_print_V + sw $t1 20($v0) + lw $t0 112($s0) + sw $v0 8($t0) + + # Type BoolOp + li $a0 20 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_BoolOp_and + sw $t1 12($v0) + la $t1 function_BoolOp_or + sw $t1 16($v0) + lw $t0 120($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 64 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 11 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 12 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 13 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 14 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 15 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 7 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 9 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Vertice__init: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_EList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Vertice_outgoing: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Vertice_number: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Vertice_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Vertice_add_out: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Vertice_print: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Edge__init: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Edge_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 24($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Edge_print: + move $fp, $sp + subu $sp, $sp, 84 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 2 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -36($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -80($fp) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -76($fp) + addiu $sp, $sp, 84 + jr $ra + +function_EList__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_EList_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_EList_head: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_EList_tail: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_EList_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_ECons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_EList_append: + move $fp, $sp + subu $sp, $sp, 48 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -36($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ASSIGN + lw $a0, 16($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 48 + jr $ra + +function_EList_print: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_ECons__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_EList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_ECons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_ECons_head: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_ECons_tail: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_ECons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_ECons_print: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_VList__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VList_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VList_head: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_VList_tail: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_VList_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_VCons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_VList_print: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_VCons__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_VList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VCons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VCons_head: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VCons_tail: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_VCons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_VCons_print: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Parse__init: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 120($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_BoolOp__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Parse_read_input: + move $fp, $sp + subu $sp, $sp, 116 + # ALLOCATE + lw $t0 112($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Graph__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -56($fp) + la $a0, data_0 + sw $a0 16($a1) + + lw $t0 -12($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_1 + li $a2 12 + beq $a0 $a2 _eq_int_bool_1 + li $a2 13 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -48($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -48($fp) +end_equal_1_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # - + li $a0 1 + lw $a1, -36($fp) + sub $a0, $a0, $a1 + sw $a0, -40($fp) + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_5 + sw $a0 16($a1) + + lw $t0 -12($fp) + lw $t1 -84($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_2 + li $a2 12 + beq $a0 $a2 _eq_int_bool_2 + li $a2 13 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -76($fp) +end_equal_2_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # - + li $a0 1 + lw $a1, -64($fp) + sub $a0, $a0, $a1 + sw $a0, -68($fp) + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -28($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -28($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + lw $a2, -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_3 + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -104($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_4: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 116 + jr $ra + +function_Parse_parse_line: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Vertice__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_5: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -52($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -60($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_3 + li $a2 12 + beq $a0 $a2 _eq_int_bool_3 + li $a2 13 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -44($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -44($fp) +end_equal_3_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -48($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # - + li $a0 1 + lw $a1, -32($fp) + sub $a0, $a0, $a1 + sw $a0, -36($fp) + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_6 + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -76($fp) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Edge__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -120($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -100($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_7: + # ALLOCATE + la $v0 type_void + sw $v0 -24($fp) + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 124 + jr $ra + +function_Parse_c2i: + move $fp, $sp + subu $sp, $sp, 316 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_7 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_4 + li $a2 12 + beq $a0 $a2 _eq_int_bool_4 + li $a2 13 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -8($fp) +end_equal_4_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_8 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -40($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_5 + li $a2 12 + beq $a0 $a2 _eq_int_bool_5 + li $a2 13 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -32($fp) +end_equal_5_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_9 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_6 + li $a2 12 + beq $a0 $a2 _eq_int_bool_6 + li $a2 13 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -56($fp) +end_equal_6_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_12 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_10 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_7 + li $a2 12 + beq $a0 $a2 _eq_int_bool_7 + li $a2 13 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 -80($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 -80($fp) +end_equal_7_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_14 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_11 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -112($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_8 + li $a2 12 + beq $a0 $a2 _eq_int_bool_8 + li $a2 13 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -104($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -104($fp) +end_equal_8_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_16 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_12 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_9 + li $a2 12 + beq $a0 $a2 _eq_int_bool_9 + li $a2 13 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -128($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -128($fp) +end_equal_9_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # IF GOTO + lw $a0, -124($fp) + bnez $a0, _cil_label_LABEL_18 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -164($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -160($fp) + la $a0, data_13 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -160($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_10 + li $a2 12 + beq $a0 $a2 _eq_int_bool_10 + li $a2 13 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -152($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -152($fp) +end_equal_10_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -148($fp) + + # IF GOTO + lw $a0, -148($fp) + bnez $a0, _cil_label_LABEL_20 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -184($fp) + la $a0, data_14 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -184($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_11 + li $a2 12 + beq $a0 $a2 _eq_int_bool_11 + li $a2 13 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -176($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -176($fp) +end_equal_11_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # IF GOTO + lw $a0, -172($fp) + bnez $a0, _cil_label_LABEL_22 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + lw $a0 -212($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -208($fp) + la $a0, data_15 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -208($fp) + beq $t0 $zero _eq_false_12_ + beq $t1 $zero _eq_false_12_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_12 + li $a2 12 + beq $a0 $a2 _eq_int_bool_12 + li $a2 13 + bne $a0 $a2 _not_basic_type_12_ +_eq_str_12_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_12_ + beq $t3 $0 _eq_true_12_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_12_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_12_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_12_ + b _eq_true_12_ +_not_basic_type_12_: + bne $t0 $t1 _eq_false_12_ + b _eq_true_12_ +_eq_int_bool_12: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_12_ +_eq_true_12_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_12_ +_eq_false_12_: + li $a0 0 + sw $a0 -200($fp) +end_equal_12_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_24 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -232($fp) + lw $a0 -236($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -232($fp) + la $a0, data_16 + sw $a0 16($a1) + + lw $t0 16($fp) + lw $t1 -232($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_13 + li $a2 12 + beq $a0 $a2 _eq_int_bool_13 + li $a2 13 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -224($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -224($fp) +end_equal_13_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -228($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # IF GOTO + lw $a0, -220($fp) + bnez $a0, _cil_label_LABEL_26 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 30 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_17 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -256($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -240($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -240($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -264($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -264($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + lw $a2, -264($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -272($fp) + sw $a0, -216($fp) + + # GOTO + j _cil_label_LABEL_27 + +_cil_label_LABEL_26: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 9 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -276($fp) + sw $a0, -216($fp) + +_cil_label_LABEL_27: + # ASSIGN + lw $a0, -216($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_25 + +_cil_label_LABEL_24: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -280($fp) + li $a0, 8 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -280($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_25: + # ASSIGN + lw $a0, -192($fp) + sw $a0, -168($fp) + + # GOTO + j _cil_label_LABEL_23 + +_cil_label_LABEL_22: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + li $a0, 7 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -284($fp) + sw $a0, -168($fp) + +_cil_label_LABEL_23: + # ASSIGN + lw $a0, -168($fp) + sw $a0, -144($fp) + + # GOTO + j _cil_label_LABEL_21 + +_cil_label_LABEL_20: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 6 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -288($fp) + sw $a0, -144($fp) + +_cil_label_LABEL_21: + # ASSIGN + lw $a0, -144($fp) + sw $a0, -120($fp) + + # GOTO + j _cil_label_LABEL_19 + +_cil_label_LABEL_18: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + li $a0, 5 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -292($fp) + sw $a0, -120($fp) + +_cil_label_LABEL_19: + # ASSIGN + lw $a0, -120($fp) + sw $a0, -96($fp) + + # GOTO + j _cil_label_LABEL_17 + +_cil_label_LABEL_16: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + li $a0, 4 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -296($fp) + sw $a0, -96($fp) + +_cil_label_LABEL_17: + # ASSIGN + lw $a0, -96($fp) + sw $a0, -72($fp) + + # GOTO + j _cil_label_LABEL_15 + +_cil_label_LABEL_14: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 3 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -300($fp) + sw $a0, -72($fp) + +_cil_label_LABEL_15: + # ASSIGN + lw $a0, -72($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_12: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 2 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_13: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -308($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_11: + # ASSIGN + lw $a0, -24($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -312($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -312($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_9: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 316 + jr $ra + +function_Parse_a2i: + move $fp, $sp + subu $sp, $sp, 228 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_14_ + beq $t1 $zero _eq_false_14_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_14 + li $a2 12 + beq $a0 $a2 _eq_int_bool_14 + li $a2 13 + bne $a0 $a2 _not_basic_type_14_ +_eq_str_14_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_14_ + beq $t3 $0 _eq_true_14_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_14_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_14_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_14_ + b _eq_true_14_ +_not_basic_type_14_: + bne $t0 $t1 _eq_false_14_ + b _eq_true_14_ +_eq_int_bool_14: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_14_ +_eq_true_14_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_14_ +_eq_false_14_: + li $a0 0 + sw $a0 -8($fp) +end_equal_14_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_28 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_18 + sw $a0 16($a1) + + lw $t0 -48($fp) + lw $t1 -60($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_15 + li $a2 12 + beq $a0 $a2 _eq_int_bool_15 + li $a2 13 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -36($fp) +end_equal_15_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_30 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -100($fp) + la $a0, data_19 + sw $a0 16($a1) + + lw $t0 -88($fp) + lw $t1 -100($fp) + beq $t0 $zero _eq_false_16_ + beq $t1 $zero _eq_false_16_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_16 + li $a2 12 + beq $a0 $a2 _eq_int_bool_16 + li $a2 13 + bne $a0 $a2 _not_basic_type_16_ +_eq_str_16_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_16_ + beq $t3 $0 _eq_true_16_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_16_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_16_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_16_ + b _eq_true_16_ +_not_basic_type_16_: + bne $t0 $t1 _eq_false_16_ + b _eq_true_16_ +_eq_int_bool_16: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_16_ +_eq_true_16_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_16_ +_eq_false_16_: + li $a0 0 + sw $a0 -76($fp) +end_equal_16_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_32 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -112($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_33 + +_cil_label_LABEL_32: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # GETATTR + lw $a1 -156($fp) + lw $a0 12($a1) + sw $a0 -140($fp) + + # - + lw $a0, -136($fp) + lw $a1, -140($fp) + sub $a0, $a0, $a1 + sw $a0, -132($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -132($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -128($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_33: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_31 + +_cil_label_LABEL_30: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -212($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # GETATTR + lw $a1 -216($fp) + lw $a0 12($a1) + sw $a0 -200($fp) + + # - + lw $a0, -196($fp) + lw $a1, -200($fp) + sub $a0, $a0, $a1 + sw $a0, -192($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -184($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -184($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + lw $a2, -184($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -176($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -176($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + lw $a2, -176($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # - + li $a0 0 + lw $a1, -164($fp) + sub $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_31: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_29 + +_cil_label_LABEL_28: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_29: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 228 + jr $ra + +function_Parse_a2i_aux: + move $fp, $sp + subu $sp, $sp, 352 + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_34: + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_35 + + # GOTO + j _cil_label_LABEL_36 + +_cil_label_LABEL_35: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -68($fp) + la $a0, data_19 + sw $a0 16($a1) + + lw $t0 -44($fp) + lw $t1 -68($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_17 + li $a2 12 + beq $a0 $a2 _eq_int_bool_17 + li $a2 13 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -60($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -60($fp) +end_equal_17_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # IF GOTO + lw $a0, -56($fp) + bnez $a0, _cil_label_LABEL_37 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -92($fp) + la $a0, data_2 + sw $a0 16($a1) + + lw $t0 -44($fp) + lw $t1 -92($fp) + beq $t0 $zero _eq_false_18_ + beq $t1 $zero _eq_false_18_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_18 + li $a2 12 + beq $a0 $a2 _eq_int_bool_18 + li $a2 13 + bne $a0 $a2 _not_basic_type_18_ +_eq_str_18_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_18_ + beq $t3 $0 _eq_true_18_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_18_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_18_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_18_ + b _eq_true_18_ +_not_basic_type_18_: + bne $t0 $t1 _eq_false_18_ + b _eq_true_18_ +_eq_int_bool_18: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_18_ +_eq_true_18_: + li $a0 1 + sw $a0 -84($fp) + b end_equal_18_ +_eq_false_18_: + li $a0 0 + sw $a0 -84($fp) +end_equal_18_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -88($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # IF GOTO + lw $a0, -80($fp) + bnez $a0, _cil_label_LABEL_39 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + li $a0, 10 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -120($fp) + + # GETATTR + lw $a1 -132($fp) + lw $a0 12($a1) + sw $a0 -124($fp) + + # * + lw $a0, -120($fp) + lw $a1, -124($fp) + mul $a0, $a0, $a1 + sw $a0, -116($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -152($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -148($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -136($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -136($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + lw $a2, -136($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # + + lw $a0, -104($fp) + lw $a1, -108($fp) + add $a0, $a0, $a1 + sw $a0, -100($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -160($fp) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -164($fp) + + # + + lw $a0, -160($fp) + lw $a1, -164($fp) + add $a0, $a0, $a1 + sw $a0, -156($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + lw $a0 -156($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -168($fp) + sw $a0, -12($fp) + + lw $t0 -12($fp) + lw $t1 -8($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 11 + beq $a0 $a2 _eq_int_bool_19 + li $a2 12 + beq $a0 $a2 _eq_int_bool_19 + li $a2 13 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -184($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -184($fp) +end_equal_19_: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + lw $a0 -184($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -188($fp) + lw $a0 12($a1) + sw $a0 -180($fp) + + # IF GOTO + lw $a0, -180($fp) + bnez $a0, _cil_label_LABEL_41 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -196($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -196($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + lw $a0 -196($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -192($fp) + la $a0, data_0 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -192($fp) + sw $a0, -176($fp) + + # GOTO + j _cil_label_LABEL_42 + +_cil_label_LABEL_41: + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + li $a0, 0 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 104($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -200($fp) + lw $a0 -204($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -200($fp) + la $a0, data_0 + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -200($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -200($fp) + sw $a0, -176($fp) + +_cil_label_LABEL_42: + # ASSIGN + lw $a0, -176($fp) + sw $a0, -76($fp) + + # GOTO + j _cil_label_LABEL_40 + +_cil_label_LABEL_39: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -252($fp) + lw $a0 12($a1) + sw $a0 -236($fp) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -240($fp) + + # - + lw $a0, -236($fp) + lw $a1, -240($fp) + sub $a0, $a0, $a1 + sw $a0, -232($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + lw $a0 -232($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -244($fp) + lw $a0 12($a1) + sw $a0 -220($fp) + + # GETATTR + lw $a1 -256($fp) + lw $a0 12($a1) + sw $a0 -224($fp) + + # - + lw $a0, -220($fp) + lw $a1, -224($fp) + sub $a0, $a0, $a1 + sw $a0, -216($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + lw $a0 -216($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -228($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -276($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -276($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -264($fp) + + # GETATTR + lw $a1 -276($fp) + lw $a0 12($a1) + sw $a0 -268($fp) + + # + + lw $a0, -264($fp) + lw $a1, -268($fp) + add $a0, $a0, $a1 + sw $a0, -260($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -272($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -212($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, -12($fp) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, -76($fp) + +_cil_label_LABEL_40: + # ASSIGN + lw $a0, -76($fp) + sw $a0, -52($fp) + + # GOTO + j _cil_label_LABEL_38 + +_cil_label_LABEL_37: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -320($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -320($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -324($fp) + lw $a2, -320($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -324($fp) + lw $a0 12($a1) + sw $a0 -308($fp) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -312($fp) + + # - + lw $a0, -308($fp) + lw $a1, -312($fp) + sub $a0, $a0, $a1 + sw $a0, -304($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -328($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -316($fp) + lw $a0 12($a1) + sw $a0 -292($fp) + + # GETATTR + lw $a1 -328($fp) + lw $a0 12($a1) + sw $a0 -296($fp) + + # - + lw $a0, -292($fp) + lw $a1, -296($fp) + sub $a0, $a0, $a1 + sw $a0, -288($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + lw $a0 -288($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -300($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -336($fp) + + # GETATTR + lw $a1 -348($fp) + lw $a0 12($a1) + sw $a0 -340($fp) + + # + + lw $a0, -336($fp) + lw $a1, -340($fp) + add $a0, $a0, $a1 + sw $a0, -332($fp) + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + lw $a0 -332($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -344($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -280($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -280($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + lw $a2, -280($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -284($fp) + sw $a0 16($a1) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, -12($fp) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, -52($fp) + +_cil_label_LABEL_38: + # GOTO + j _cil_label_LABEL_34 + +_cil_label_LABEL_36: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 352 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Parse__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -12($fp) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -20($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 88($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Graph__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_VList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_EList__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Graph_add_vertice: + move $fp, $sp + subu $sp, $sp, 32 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -4($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 16($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Graph_print_E: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Graph_print_V: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_BoolOp__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_BoolOp_and: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_43 + + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_44 + +_cil_label_LABEL_43: + # ASSIGN + lw $a0, 20($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_44: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 12 + jr $ra + +function_BoolOp_or: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_45 + + # ASSIGN + lw $a0, 20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_45: + # ALLOCATE + lw $t0 96($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -8($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_46: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 12 + jr $ra + + +##################################### + diff --git a/tests/codegen/hairyscary.mips b/tests/codegen/hairyscary.mips new file mode 100644 index 00000000..7a2f22e6 --- /dev/null +++ b/tests/codegen/hairyscary.mips @@ -0,0 +1,3003 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "do nothing" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Bazz: .align 2 + .asciiz "Bazz" + classname_Foo: .align 2 + .asciiz "Foo" + classname_Razz: .align 2 + .asciiz "Razz" + classname_Bar: .align 2 + .asciiz "Bar" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Main: .align 2 + .asciiz "Main" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 44 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Bazz + sw $t1 12($s1) + la $t1 classname_Foo + sw $t1 16($s1) + la $t1 classname_Razz + sw $t1 20($s1) + la $t1 classname_Bar + sw $t1 24($s1) + la $t1 classname_Int + sw $t1 28($s1) + la $t1 classname_Bool + sw $t1 32($s1) + la $t1 classname_String + sw $t1 36($s1) + la $t1 classname_Main + sw $t1 40($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 88 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Bazz + li $a0 24 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Foo + li $a0 32 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 32 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Razz + li $a0 40 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 40 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Bar + li $a0 48 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 48 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type Main + li $a0 28 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 28 + sw $a0 4($v0) + sw $v0 80($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Bazz + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Bazz_printh + sw $t1 28($v0) + la $t1 function_Bazz_doh + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Foo + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Bazz_printh + sw $t1 28($v0) + la $t1 function_Foo_doh + sw $t1 32($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Razz + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Bazz_printh + sw $t1 28($v0) + la $t1 function_Foo_doh + sw $t1 32($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Bar + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Bazz_printh + sw $t1 28($v0) + la $t1 function_Foo_doh + sw $t1 32($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Main_main + sw $t1 12($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 44 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 4 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 5 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bazz__init: + move $fp, $sp + subu $sp, $sp, 48 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # PUSHPARAM + li $a0, 6 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + li $a0, 5 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_1 + + # PUSHPARAM + li $a0, 4 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_2 + + # PUSHPARAM + li $a0, 3 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_3 + +_cil_label_LABEL_0: + # ASSIGN + lw $a0, 12($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_1: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bar__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -16($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Razz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -24($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Foo__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -32($fp) + sw $a0, -12($fp) + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_4: + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -44($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 48 + jr $ra + +function_Bazz_printh: + move $fp, $sp + subu $sp, $sp, 16 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Bazz_doh: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # + + lw $a0, -8($fp) + lw $a1, -12($fp) + add $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Foo__init: + move $fp, $sp + subu $sp, $sp, 116 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bazz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 6 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_5 + + # PUSHPARAM + li $a0, 5 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_6 + + # PUSHPARAM + li $a0, 4 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_7 + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, 12($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_8 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bar__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -12($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_8 + +_cil_label_LABEL_7: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Razz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -20($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_8 + +_cil_label_LABEL_8: + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 24($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -76($fp) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -76($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -88($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # + + lw $a0, -64($fp) + lw $a1, -68($fp) + add $a0, $a0, $a1 + sw $a0, -60($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # GETATTR + lw $a1 -104($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # + + lw $a0, -48($fp) + lw $a1, -52($fp) + add $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -56($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # + + lw $a0, -32($fp) + lw $a1, -36($fp) + add $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -40($fp) + sw $a0 28($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 116 + jr $ra + +function_Foo_doh: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 2 + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # + + lw $a0, -8($fp) + lw $a1, -12($fp) + add $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Razz__init: + move $fp, $sp + subu $sp, $sp, 132 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Foo__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # PUSHPARAM + li $a0, 6 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_9 + + # PUSHPARAM + li $a0, 5 + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function___conforms + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # IF GOTO + lw $a0, 0($fp) + bnez $a0, _cil_label_LABEL_10 + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, 12($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bar__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -12($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_11: + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 32($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -84($fp) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + li $a2, 3 + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + li $a2, 3 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -92($fp) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -92($fp) + lw $a0 0($a1) + sw $a0 -96($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -96($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + lw $a2, -96($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -88($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # + + lw $a0, -72($fp) + lw $a1, -76($fp) + add $a0, $a0, $a1 + sw $a0, -68($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 32($a1) + sw $a0 -104($fp) + + # PUSHPARAM + lw $a0, -104($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -104($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # + + lw $a0, -56($fp) + lw $a1, -60($fp) + add $a0, $a0, $a1 + sw $a0, -52($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # + + lw $a0, -40($fp) + lw $a1, -44($fp) + add $a0, $a0, $a1 + sw $a0, -36($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -124($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -124($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + lw $a2, -124($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -48($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # + + lw $a0, -24($fp) + lw $a1, -28($fp) + add $a0, $a0, $a1 + sw $a0, -20($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -32($fp) + sw $a0 36($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 132 + jr $ra + +function_Bar__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Razz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 40($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 44($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 32 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bazz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Foo__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Razz__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -16($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bar__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -24($fp) + sw $a0 24($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 8 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 10 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 0($fp) + la $a0, data_1 + sw $a0 16($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 8 + jr $ra + + +##################################### + diff --git a/tests/codegen/hello_world.mips b/tests/codegen/hello_world.mips new file mode 100644 index 00000000..7ea75834 --- /dev/null +++ b/tests/codegen/hello_world.mips @@ -0,0 +1,1087 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "Hello, World.\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 14 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/hello_world.s b/tests/codegen/hello_world.s new file mode 100644 index 00000000..93c053f0 --- /dev/null +++ b/tests/codegen/hello_world.s @@ -0,0 +1,1083 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "Hello, World.\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 14 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/io.mips b/tests/codegen/io.mips new file mode 100644 index 00000000..72d4ac71 --- /dev/null +++ b/tests/codegen/io.mips @@ -0,0 +1,2045 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "C: Hello world\n" + data_2: .align 2 + .asciiz "D: Hello world\n" + data_3: .align 2 + .asciiz "Done.\n" + data_4: .align 2 + .asciiz "A: Hello world\n" + data_5: .align 2 + .asciiz "B: Hello world\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_C: .align 2 + .asciiz "C" + classname_D: .align 2 + .asciiz "D" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_A: .align 2 + .asciiz "A" + classname_B: .align 2 + .asciiz "B" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 44 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_C + sw $t1 12($s1) + la $t1 classname_D + sw $t1 16($s1) + la $t1 classname_Main + sw $t1 20($s1) + la $t1 classname_Int + sw $t1 24($s1) + la $t1 classname_Bool + sw $t1 28($s1) + la $t1 classname_String + sw $t1 32($s1) + la $t1 classname_A + sw $t1 36($s1) + la $t1 classname_B + sw $t1 40($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 88 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type C + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type D + li $a0 12 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type A + li $a0 16 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 72($s0) + + # Type B + li $a0 16 + li $v0 9 + syscall + li $a0 10 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 80($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type C + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_C_out_c + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type D + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_C_out_c + sw $t1 28($v0) + la $t1 function_D_out_d + sw $t1 32($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type A + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_out_a + sw $t1 12($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + # Type B + li $a0 20 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_A_out_a + sw $t1 12($v0) + la $t1 function_B_out_b + sw $t1 16($v0) + lw $t0 80($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 44 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 10 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 9 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_C__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_C_out_c: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_D__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_D_out_d: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 80 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 80($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_B__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_C__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -32($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_D__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 6 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -68($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_A__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_A_out_a: + move $fp, $sp + subu $sp, $sp, 20 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 20 + jr $ra + +function_B__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_A__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_B_out_b: + move $fp, $sp + subu $sp, $sp, 20 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 20 + jr $ra + + +##################################### + diff --git a/tests/codegen/life.mips b/tests/codegen/life.mips new file mode 100644 index 00000000..b5f7671a --- /dev/null +++ b/tests/codegen/life.mips @@ -0,0 +1,17702 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + data_2: .align 2 + .asciiz " " + data_3: .align 2 + .asciiz "X" + data_4: .align 2 + .asciiz "-" + data_5: .align 2 + .asciiz "\nPlease chose a number:\n" + data_6: .align 2 + .asciiz "\t1: A cross\n" + data_7: .align 2 + .asciiz "\t2: A slash from the upper left to lower right\n" + data_8: .align 2 + .asciiz "\t3: A slash from the upper right to lower left\n" + data_9: .align 2 + .asciiz "\t4: An X\n" + data_10: .align 2 + .asciiz "\t5: A greater than sign \n" + data_11: .align 2 + .asciiz "\t6: A less than sign\n" + data_12: .align 2 + .asciiz "\t7: Two greater than signs\n" + data_13: .align 2 + .asciiz "\t8: Two less than signs\n" + data_14: .align 2 + .asciiz "\t9: A 'V'\n" + data_15: .align 2 + .asciiz "\t10: An inverse 'V'\n" + data_16: .align 2 + .asciiz "\t11: Numbers 9 and 10 combined\n" + data_17: .align 2 + .asciiz "\t12: A full grid\n" + data_18: .align 2 + .asciiz "\t13: A 'T'\n" + data_19: .align 2 + .asciiz "\t14: A plus '+'\n" + data_20: .align 2 + .asciiz "\t15: A 'W'\n" + data_21: .align 2 + .asciiz "\t16: An 'M'\n" + data_22: .align 2 + .asciiz "\t17: An 'E'\n" + data_23: .align 2 + .asciiz "\t18: A '3'\n" + data_24: .align 2 + .asciiz "\t19: An 'O'\n" + data_25: .align 2 + .asciiz "\t20: An '8'\n" + data_26: .align 2 + .asciiz "\t21: An 'S'\n" + data_27: .align 2 + .asciiz "Your choice => " + data_28: .align 2 + .asciiz " " + data_29: .align 2 + .asciiz " XXXX X XX X XXXX " + data_30: .align 2 + .asciiz " XX X XX X XX X XX X XX " + data_31: .align 2 + .asciiz " XX X XX X XX " + data_32: .align 2 + .asciiz "XXX X X X X XXXX " + data_33: .align 2 + .asciiz "XXXXX X XXXXX X XXXX" + data_34: .align 2 + .asciiz " X X X X X X X" + data_35: .align 2 + .asciiz "X X X X X X X " + data_36: .align 2 + .asciiz " X X XXXXX X X " + data_37: .align 2 + .asciiz "XXXXX X X X X " + data_38: .align 2 + .asciiz "XXXXXXXXXXXXXXXXXXXXXXXXX" + data_39: .align 2 + .asciiz "X X X X X X X X" + data_40: .align 2 + .asciiz " X X X X X" + data_41: .align 2 + .asciiz "X X X X X " + data_42: .align 2 + .asciiz " X XX X X X " + data_43: .align 2 + .asciiz "X X X XX X " + data_44: .align 2 + .asciiz " X X X X X" + data_45: .align 2 + .asciiz "X X X X X " + data_46: .align 2 + .asciiz "X X X X X X X X X" + data_47: .align 2 + .asciiz "X X X X X" + data_48: .align 2 + .asciiz " X X X X X " + data_49: .align 2 + .asciiz " XX XXXX XXXX XX " + data_50: .align 2 + .asciiz "Would you like to continue with the next generation? \n" + data_51: .align 2 + .asciiz "Please use lowercase y or n for your answer [y]: " + data_52: .align 2 + .asciiz "n" + data_53: .align 2 + .asciiz "\n\n" + data_54: .align 2 + .asciiz "Would you like to choose a background pattern? \n" + data_55: .align 2 + .asciiz "Please use lowercase y or n for your answer [n]: " + data_56: .align 2 + .asciiz "y" + data_57: .align 2 + .asciiz "Welcome to the Game of Life.\n" + data_58: .align 2 + .asciiz "There are many initial states to choose from. \n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Board: .align 2 + .asciiz "Board" + classname_CellularAutomaton: .align 2 + .asciiz "CellularAutomaton" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 36 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Board + sw $t1 12($s1) + la $t1 classname_CellularAutomaton + sw $t1 16($s1) + la $t1 classname_Main + sw $t1 20($s1) + la $t1 classname_Int + sw $t1 24($s1) + la $t1 classname_Bool + sw $t1 28($s1) + la $t1 classname_String + sw $t1 32($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 72 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Board + li $a0 24 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 24 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type CellularAutomaton + li $a0 28 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 28 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 32 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 64($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Board + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Board_size_of_board + sw $t1 28($v0) + la $t1 function_Board_board_init + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type CellularAutomaton + li $a0 108 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Board_size_of_board + sw $t1 28($v0) + la $t1 function_Board_board_init + sw $t1 32($v0) + la $t1 function_CellularAutomaton_init + sw $t1 36($v0) + la $t1 function_CellularAutomaton_print + sw $t1 40($v0) + la $t1 function_CellularAutomaton_num_cells + sw $t1 44($v0) + la $t1 function_CellularAutomaton_cell + sw $t1 48($v0) + la $t1 function_CellularAutomaton_north + sw $t1 52($v0) + la $t1 function_CellularAutomaton_south + sw $t1 56($v0) + la $t1 function_CellularAutomaton_east + sw $t1 60($v0) + la $t1 function_CellularAutomaton_west + sw $t1 64($v0) + la $t1 function_CellularAutomaton_northwest + sw $t1 68($v0) + la $t1 function_CellularAutomaton_northeast + sw $t1 72($v0) + la $t1 function_CellularAutomaton_southeast + sw $t1 76($v0) + la $t1 function_CellularAutomaton_southwest + sw $t1 80($v0) + la $t1 function_CellularAutomaton_neighbors + sw $t1 84($v0) + la $t1 function_CellularAutomaton_cell_at_next_evolution + sw $t1 88($v0) + la $t1 function_CellularAutomaton_evolve + sw $t1 92($v0) + la $t1 function_CellularAutomaton_option + sw $t1 96($v0) + la $t1 function_CellularAutomaton_prompt + sw $t1 100($v0) + la $t1 function_CellularAutomaton_prompt2 + sw $t1 104($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Main + li $a0 112 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Board_size_of_board + sw $t1 28($v0) + la $t1 function_Board_board_init + sw $t1 32($v0) + la $t1 function_CellularAutomaton_init + sw $t1 36($v0) + la $t1 function_CellularAutomaton_print + sw $t1 40($v0) + la $t1 function_CellularAutomaton_num_cells + sw $t1 44($v0) + la $t1 function_CellularAutomaton_cell + sw $t1 48($v0) + la $t1 function_CellularAutomaton_north + sw $t1 52($v0) + la $t1 function_CellularAutomaton_south + sw $t1 56($v0) + la $t1 function_CellularAutomaton_east + sw $t1 60($v0) + la $t1 function_CellularAutomaton_west + sw $t1 64($v0) + la $t1 function_CellularAutomaton_northwest + sw $t1 68($v0) + la $t1 function_CellularAutomaton_northeast + sw $t1 72($v0) + la $t1 function_CellularAutomaton_southeast + sw $t1 76($v0) + la $t1 function_CellularAutomaton_southwest + sw $t1 80($v0) + la $t1 function_CellularAutomaton_neighbors + sw $t1 84($v0) + la $t1 function_CellularAutomaton_cell_at_next_evolution + sw $t1 88($v0) + la $t1 function_CellularAutomaton_evolve + sw $t1 92($v0) + la $t1 function_CellularAutomaton_option + sw $t1 96($v0) + la $t1 function_CellularAutomaton_prompt + sw $t1 100($v0) + la $t1 function_CellularAutomaton_prompt2 + sw $t1 104($v0) + la $t1 function_Main_main + sw $t1 108($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 36 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 4 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Board__init: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 20($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 12 + jr $ra + +function_Board_size_of_board: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Board_board_init: + move $fp, $sp + subu $sp, $sp, 184 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 15 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_1 + li $a2 7 + beq $a0 $a2 _eq_int_bool_1 + li $a2 8 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -16($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -16($fp) +end_equal_1_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # IF GOTO + lw $a0, -12($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 16 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -44($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_2 + li $a2 7 + beq $a0 $a2 _eq_int_bool_2 + li $a2 8 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -36($fp) +end_equal_2_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 20 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -64($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_3 + li $a2 7 + beq $a0 $a2 _eq_int_bool_3 + li $a2 8 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -56($fp) +end_equal_3_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 21 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -84($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_4 + li $a2 7 + beq $a0 $a2 _eq_int_bool_4 + li $a2 8 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -76($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -76($fp) +end_equal_4_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + li $a0, 25 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -104($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_5 + li $a2 7 + beq $a0 $a2 _eq_int_bool_5 + li $a2 8 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 -96($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 -96($fp) +end_equal_5_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # IF GOTO + lw $a0, -92($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 28 + sw $a0 12($a1) + + lw $t0 -4($fp) + lw $t1 -124($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_6 + li $a2 7 + beq $a0 $a2 _eq_int_bool_6 + li $a2 8 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -116($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -116($fp) +end_equal_6_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # IF GOTO + lw $a0, -112($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -132($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -108($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 7 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 4 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -140($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -108($fp) + +_cil_label_LABEL_11: + # ASSIGN + lw $a0, -108($fp) + sw $a0, -88($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -148($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -148($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -88($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -88($fp) + sw $a0, -68($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + li $a0, 3 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 7 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -156($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -68($fp) + +_cil_label_LABEL_7: + # ASSIGN + lw $a0, -68($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 4 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -160($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -164($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -48($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + li $a0, 4 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 4 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -172($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -28($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 3 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 5 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -180($fp) + sw $a0 16($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 20($a1) + + # ASSIGN + lw $a0, -4($fp) + sw $a0, -8($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 184 + jr $ra + +function_CellularAutomaton__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Board__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 24($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_CellularAutomaton_init: + move $fp, $sp + subu $sp, $sp, 8 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 24($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 32($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_CellularAutomaton_print: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -4($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_12: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -4($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # < + lw $a1, -36($fp) + lw $a2, -40($fp) + slt $a0, $a1, $a2 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_13 + + # GOTO + j _cil_label_LABEL_14 + +_cil_label_LABEL_13: + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -56($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # GETATTR + lw $a1 -104($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # + + lw $a0, -92($fp) + lw $a1, -96($fp) + add $a0, $a0, $a1 + sw $a0, -88($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_12 + +_cil_label_LABEL_14: + # ALLOCATE + la $v0 type_void + sw $v0 -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + lw $a0 -120($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -116($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -116($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -108($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -108($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + lw $a2, -108($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 124 + jr $ra + +function_CellularAutomaton_num_cells: + move $fp, $sp + subu $sp, $sp, 12 + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_CellularAutomaton_cell: + move $fp, $sp + subu $sp, $sp, 72 + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -40($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # - + lw $a0, -28($fp) + lw $a1, -32($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_15 + + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -48($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -56($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_16 + +_cil_label_LABEL_15: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -64($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_16: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 72 + jr $ra + +function_CellularAutomaton_north: + move $fp, $sp + subu $sp, $sp, 84 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -40($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # - + lw $a0, -28($fp) + lw $a1, -32($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_17 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -72($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # - + lw $a0, -60($fp) + lw $a1, -64($fp) + sub $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_18 + +_cil_label_LABEL_17: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -76($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -76($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_18: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_south: + move $fp, $sp + subu $sp, $sp, 84 + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # + + lw $a0, -32($fp) + lw $a1, -36($fp) + add $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_19 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -72($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_20 + +_cil_label_LABEL_19: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -76($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -76($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_20: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 84 + jr $ra + +function_CellularAutomaton_east: + move $fp, $sp + subu $sp, $sp, 132 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # + + lw $a0, -52($fp) + lw $a1, -56($fp) + add $a0, $a0, $a1 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # / + lw $a0, -36($fp) + lw $a1, -40($fp) + beqz $a1 _div_error_7_ + div $a0, $a0, $a1 + sw $a0, -32($fp) + b _div_end_7_ +_div_error_7_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_7_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -72($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # * + lw $a0, -20($fp) + lw $a1, -24($fp) + mul $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -80($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # + + lw $a0, -80($fp) + lw $a1, -84($fp) + add $a0, $a0, $a1 + sw $a0, -76($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + lw $t0 -28($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_8 + li $a2 7 + beq $a0 $a2 _eq_int_bool_8 + li $a2 8 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 -8($fp) +end_equal_8_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_21 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # + + lw $a0, -108($fp) + lw $a1, -112($fp) + add $a0, $a0, $a1 + sw $a0, -104($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + lw $a0 -104($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -116($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -96($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -96($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + lw $a2, -96($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -100($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_22 + +_cil_label_LABEL_21: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -124($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -124($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_22: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 132 + jr $ra + +function_CellularAutomaton_west: + move $fp, $sp + subu $sp, $sp, 120 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 16($fp) + lw $t1 -16($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_9 + li $a2 7 + beq $a0 $a2 _eq_int_bool_9 + li $a2 8 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -8($fp) +end_equal_9_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_23 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # / + lw $a0, -56($fp) + lw $a1, -60($fp) + beqz $a1 _div_error_10_ + div $a0, $a0, $a1 + sw $a0, -52($fp) + b _div_end_10_ +_div_error_10_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_10_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -52($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -72($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # * + lw $a0, -40($fp) + lw $a1, -44($fp) + mul $a0, $a0, $a1 + sw $a0, -36($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + lw $t0 -48($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_11_ + beq $t1 $zero _eq_false_11_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_11 + li $a2 7 + beq $a0 $a2 _eq_int_bool_11 + li $a2 8 + bne $a0 $a2 _not_basic_type_11_ +_eq_str_11_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_11_ + beq $t3 $0 _eq_true_11_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_11_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_11_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_11_ + b _eq_true_11_ +_not_basic_type_11_: + bne $t0 $t1 _eq_false_11_ + b _eq_true_11_ +_eq_int_bool_11: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_11_ +_eq_true_11_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_11_ +_eq_false_11_: + li $a0 0 + sw $a0 -28($fp) +end_equal_11_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # IF GOTO + lw $a0, -24($fp) + bnez $a0, _cil_label_LABEL_25 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # - + lw $a0, -88($fp) + lw $a1, -92($fp) + sub $a0, $a0, $a1 + sw $a0, -84($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -80($fp) + sw $a0, -20($fp) + + # GOTO + j _cil_label_LABEL_26 + +_cil_label_LABEL_25: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -104($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -104($fp) + sw $a0, -20($fp) + +_cil_label_LABEL_26: + # ASSIGN + lw $a0, -20($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_24 + +_cil_label_LABEL_23: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_24: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_CellularAutomaton_northwest: + move $fp, $sp + subu $sp, $sp, 148 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -40($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # - + lw $a0, -28($fp) + lw $a1, -32($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_27 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -96($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # / + lw $a0, -84($fp) + lw $a1, -88($fp) + beqz $a1 _div_error_12_ + div $a0, $a0, $a1 + sw $a0, -80($fp) + b _div_end_12_ +_div_error_12_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_12_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # * + lw $a0, -68($fp) + lw $a1, -72($fp) + mul $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + lw $t0 -76($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_13_ + beq $t1 $zero _eq_false_13_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_13 + li $a2 7 + beq $a0 $a2 _eq_int_bool_13 + li $a2 8 + bne $a0 $a2 _not_basic_type_13_ +_eq_str_13_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_13_ + beq $t3 $0 _eq_true_13_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_13_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_13_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_13_ + b _eq_true_13_ +_not_basic_type_13_: + bne $t0 $t1 _eq_false_13_ + b _eq_true_13_ +_eq_int_bool_13: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_13_ +_eq_true_13_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_13_ +_eq_false_13_: + li $a0 0 + sw $a0 -56($fp) +end_equal_13_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_29 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -116($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -120($fp) + + # - + lw $a0, -116($fp) + lw $a1, -120($fp) + sub $a0, $a0, $a1 + sw $a0, -112($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -112($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_30 + +_cil_label_LABEL_29: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -132($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -132($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_30: + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_28 + +_cil_label_LABEL_27: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -140($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -140($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_28: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 148 + jr $ra + +function_CellularAutomaton_northeast: + move $fp, $sp + subu $sp, $sp, 188 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -40($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # - + lw $a0, -28($fp) + lw $a1, -32($fp) + sub $a0, $a0, $a1 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 0 + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_31 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -116($fp) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -116($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # / + lw $a0, -84($fp) + lw $a1, -88($fp) + beqz $a1 _div_error_14_ + div $a0, $a0, $a1 + sw $a0, -80($fp) + b _div_end_14_ +_div_error_14_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_14_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -120($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # * + lw $a0, -68($fp) + lw $a1, -72($fp) + mul $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -128($fp) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # + + lw $a0, -128($fp) + lw $a1, -132($fp) + add $a0, $a0, $a1 + sw $a0, -124($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -124($fp) + sw $a0 12($a1) + + lw $t0 -76($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_15_ + beq $t1 $zero _eq_false_15_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_15 + li $a2 7 + beq $a0 $a2 _eq_int_bool_15 + li $a2 8 + bne $a0 $a2 _not_basic_type_15_ +_eq_str_15_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_15_ + beq $t3 $0 _eq_true_15_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_15_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_15_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_15_ + b _eq_true_15_ +_not_basic_type_15_: + bne $t0 $t1 _eq_false_15_ + b _eq_true_15_ +_eq_int_bool_15: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_15_ +_eq_true_15_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_15_ +_eq_false_15_: + li $a0 0 + sw $a0 -56($fp) +end_equal_15_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_33 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -160($fp) + + # + + lw $a0, -156($fp) + lw $a1, -160($fp) + add $a0, $a0, $a1 + sw $a0, -152($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -164($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -148($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_34 + +_cil_label_LABEL_33: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -172($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_34: + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_32 + +_cil_label_LABEL_31: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -184($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -180($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_32: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_CellularAutomaton_southeast: + move $fp, $sp + subu $sp, $sp, 188 + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # + + lw $a0, -32($fp) + lw $a1, -36($fp) + add $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_35 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -116($fp) + + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -116($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # / + lw $a0, -84($fp) + lw $a1, -88($fp) + beqz $a1 _div_error_16_ + div $a0, $a0, $a1 + sw $a0, -80($fp) + b _div_end_16_ +_div_error_16_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_16_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -120($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # * + lw $a0, -68($fp) + lw $a1, -72($fp) + mul $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -128($fp) + + # GETATTR + lw $a1 -140($fp) + lw $a0 12($a1) + sw $a0 -132($fp) + + # + + lw $a0, -128($fp) + lw $a1, -132($fp) + add $a0, $a0, $a1 + sw $a0, -124($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -124($fp) + sw $a0 12($a1) + + lw $t0 -76($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_17_ + beq $t1 $zero _eq_false_17_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_17 + li $a2 7 + beq $a0 $a2 _eq_int_bool_17 + li $a2 8 + bne $a0 $a2 _not_basic_type_17_ +_eq_str_17_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_17_ + beq $t3 $0 _eq_true_17_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_17_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_17_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_17_ + b _eq_true_17_ +_not_basic_type_17_: + bne $t0 $t1 _eq_false_17_ + b _eq_true_17_ +_eq_int_bool_17: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_17_ +_eq_true_17_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_17_ +_eq_false_17_: + li $a0 0 + sw $a0 -56($fp) +end_equal_17_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_37 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -168($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -160($fp) + + # + + lw $a0, -156($fp) + lw $a1, -160($fp) + add $a0, $a0, $a1 + sw $a0, -152($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + lw $a0 -152($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -164($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -148($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_38 + +_cil_label_LABEL_37: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -172($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -172($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_38: + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_36 + +_cil_label_LABEL_35: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -184($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -180($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_36: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_CellularAutomaton_southwest: + move $fp, $sp + subu $sp, $sp, 148 + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # + + lw $a0, -32($fp) + lw $a1, -36($fp) + add $a0, $a0, $a1 + sw $a0, -28($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_39 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -96($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # / + lw $a0, -84($fp) + lw $a1, -88($fp) + beqz $a1 _div_error_18_ + div $a0, $a0, $a1 + sw $a0, -80($fp) + b _div_end_18_ +_div_error_18_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_18_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # * + lw $a0, -68($fp) + lw $a1, -72($fp) + mul $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + lw $t0 -76($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_19_ + beq $t1 $zero _eq_false_19_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_19 + li $a2 7 + beq $a0 $a2 _eq_int_bool_19 + li $a2 8 + bne $a0 $a2 _not_basic_type_19_ +_eq_str_19_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_19_ + beq $t3 $0 _eq_true_19_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_19_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_19_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_19_ + b _eq_true_19_ +_not_basic_type_19_: + bne $t0 $t1 _eq_false_19_ + b _eq_true_19_ +_eq_int_bool_19: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_19_ +_eq_true_19_: + li $a0 1 + sw $a0 -56($fp) + b end_equal_19_ +_eq_false_19_: + li $a0 0 + sw $a0 -56($fp) +end_equal_19_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # IF GOTO + lw $a0, -52($fp) + bnez $a0, _cil_label_LABEL_41 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -116($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -120($fp) + + # - + lw $a0, -116($fp) + lw $a1, -120($fp) + sub $a0, $a0, $a1 + sw $a0, -112($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -112($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -108($fp) + sw $a0, -48($fp) + + # GOTO + j _cil_label_LABEL_42 + +_cil_label_LABEL_41: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -132($fp) + lw $a0 -136($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -132($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -132($fp) + sw $a0, -48($fp) + +_cil_label_LABEL_42: + # ASSIGN + lw $a0, -48($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_40 + +_cil_label_LABEL_39: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -140($fp) + la $a0, data_2 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -140($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_40: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 148 + jr $ra + +function_CellularAutomaton_neighbors: + move $fp, $sp + subu $sp, $sp, 432 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -132($fp) + lw $t1 -136($fp) + beq $t0 $zero _eq_false_20_ + beq $t1 $zero _eq_false_20_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_20 + li $a2 7 + beq $a0 $a2 _eq_int_bool_20 + li $a2 8 + bne $a0 $a2 _not_basic_type_20_ +_eq_str_20_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_20_ + beq $t3 $0 _eq_true_20_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_20_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_20_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_20_ + b _eq_true_20_ +_not_basic_type_20_: + bne $t0 $t1 _eq_false_20_ + b _eq_true_20_ +_eq_int_bool_20: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_20_ +_eq_true_20_: + li $a0 1 + sw $a0 -120($fp) + b end_equal_20_ +_eq_false_20_: + li $a0 0 + sw $a0 -120($fp) +end_equal_20_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -120($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -124($fp) + lw $a0 12($a1) + sw $a0 -116($fp) + + # IF GOTO + lw $a0, -116($fp) + bnez $a0, _cil_label_LABEL_43 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -144($fp) + sw $a0, -112($fp) + + # GOTO + j _cil_label_LABEL_44 + +_cil_label_LABEL_43: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -148($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -148($fp) + sw $a0, -112($fp) + +_cil_label_LABEL_44: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -168($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -168($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + lw $a2, -168($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + lw $a0 -180($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -176($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -172($fp) + lw $t1 -176($fp) + beq $t0 $zero _eq_false_21_ + beq $t1 $zero _eq_false_21_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_21 + li $a2 7 + beq $a0 $a2 _eq_int_bool_21 + li $a2 8 + bne $a0 $a2 _not_basic_type_21_ +_eq_str_21_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_21_ + beq $t3 $0 _eq_true_21_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_21_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_21_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_21_ + b _eq_true_21_ +_not_basic_type_21_: + bne $t0 $t1 _eq_false_21_ + b _eq_true_21_ +_eq_int_bool_21: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_21_ +_eq_true_21_: + li $a0 1 + sw $a0 -160($fp) + b end_equal_21_ +_eq_false_21_: + li $a0 0 + sw $a0 -160($fp) +end_equal_21_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -164($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -164($fp) + lw $a0 -160($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -164($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # IF GOTO + lw $a0, -156($fp) + bnez $a0, _cil_label_LABEL_45 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -184($fp) + sw $a0, -152($fp) + + # GOTO + j _cil_label_LABEL_46 + +_cil_label_LABEL_45: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -188($fp) + sw $a0, -152($fp) + +_cil_label_LABEL_46: + # GETATTR + lw $a1 -112($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # GETATTR + lw $a1 -152($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # + + lw $a0, -100($fp) + lw $a1, -104($fp) + add $a0, $a0, $a1 + sw $a0, -96($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -208($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -208($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 60($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + lw $a2, -208($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + lw $a0 -220($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -216($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -212($fp) + lw $t1 -216($fp) + beq $t0 $zero _eq_false_22_ + beq $t1 $zero _eq_false_22_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_22 + li $a2 7 + beq $a0 $a2 _eq_int_bool_22 + li $a2 8 + bne $a0 $a2 _not_basic_type_22_ +_eq_str_22_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_22_ + beq $t3 $0 _eq_true_22_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_22_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_22_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_22_ + b _eq_true_22_ +_not_basic_type_22_: + bne $t0 $t1 _eq_false_22_ + b _eq_true_22_ +_eq_int_bool_22: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_22_ +_eq_true_22_: + li $a0 1 + sw $a0 -200($fp) + b end_equal_22_ +_eq_false_22_: + li $a0 0 + sw $a0 -200($fp) +end_equal_22_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -200($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # IF GOTO + lw $a0, -196($fp) + bnez $a0, _cil_label_LABEL_47 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, -192($fp) + + # GOTO + j _cil_label_LABEL_48 + +_cil_label_LABEL_47: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -228($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -228($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -228($fp) + sw $a0, -192($fp) + +_cil_label_LABEL_48: + # GETATTR + lw $a1 -108($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # GETATTR + lw $a1 -192($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # + + lw $a0, -84($fp) + lw $a1, -88($fp) + add $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -248($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -248($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + lw $a2, -248($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -260($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -260($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -256($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -252($fp) + lw $t1 -256($fp) + beq $t0 $zero _eq_false_23_ + beq $t1 $zero _eq_false_23_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_23 + li $a2 7 + beq $a0 $a2 _eq_int_bool_23 + li $a2 8 + bne $a0 $a2 _not_basic_type_23_ +_eq_str_23_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_23_ + beq $t3 $0 _eq_true_23_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_23_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_23_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_23_ + b _eq_true_23_ +_not_basic_type_23_: + bne $t0 $t1 _eq_false_23_ + b _eq_true_23_ +_eq_int_bool_23: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_23_ +_eq_true_23_: + li $a0 1 + sw $a0 -240($fp) + b end_equal_23_ +_eq_false_23_: + li $a0 0 + sw $a0 -240($fp) +end_equal_23_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -244($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -244($fp) + lw $a0 -240($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -244($fp) + lw $a0 12($a1) + sw $a0 -236($fp) + + # IF GOTO + lw $a0, -236($fp) + bnez $a0, _cil_label_LABEL_49 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -264($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -264($fp) + sw $a0, -232($fp) + + # GOTO + j _cil_label_LABEL_50 + +_cil_label_LABEL_49: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -268($fp) + sw $a0, -232($fp) + +_cil_label_LABEL_50: + # GETATTR + lw $a1 -92($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # GETATTR + lw $a1 -232($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # + + lw $a0, -68($fp) + lw $a1, -72($fp) + add $a0, $a0, $a1 + sw $a0, -64($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -288($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -288($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 72($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + lw $a2, -288($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -296($fp) + lw $a0 -300($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -296($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -292($fp) + lw $t1 -296($fp) + beq $t0 $zero _eq_false_24_ + beq $t1 $zero _eq_false_24_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_24 + li $a2 7 + beq $a0 $a2 _eq_int_bool_24 + li $a2 8 + bne $a0 $a2 _not_basic_type_24_ +_eq_str_24_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_24_ + beq $t3 $0 _eq_true_24_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_24_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_24_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_24_ + b _eq_true_24_ +_not_basic_type_24_: + bne $t0 $t1 _eq_false_24_ + b _eq_true_24_ +_eq_int_bool_24: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_24_ +_eq_true_24_: + li $a0 1 + sw $a0 -280($fp) + b end_equal_24_ +_eq_false_24_: + li $a0 0 + sw $a0 -280($fp) +end_equal_24_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + lw $a0 -280($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -284($fp) + lw $a0 12($a1) + sw $a0 -276($fp) + + # IF GOTO + lw $a0, -276($fp) + bnez $a0, _cil_label_LABEL_51 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -272($fp) + + # GOTO + j _cil_label_LABEL_52 + +_cil_label_LABEL_51: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -308($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -308($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -308($fp) + sw $a0, -272($fp) + +_cil_label_LABEL_52: + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -272($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # + + lw $a0, -52($fp) + lw $a1, -56($fp) + add $a0, $a0, $a1 + sw $a0, -48($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -328($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -328($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -332($fp) + lw $a2, -328($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -340($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -340($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + lw $a0 -340($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -336($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -332($fp) + lw $t1 -336($fp) + beq $t0 $zero _eq_false_25_ + beq $t1 $zero _eq_false_25_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_25 + li $a2 7 + beq $a0 $a2 _eq_int_bool_25 + li $a2 8 + bne $a0 $a2 _not_basic_type_25_ +_eq_str_25_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_25_ + beq $t3 $0 _eq_true_25_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_25_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_25_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_25_ + b _eq_true_25_ +_not_basic_type_25_: + bne $t0 $t1 _eq_false_25_ + b _eq_true_25_ +_eq_int_bool_25: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_25_ +_eq_true_25_: + li $a0 1 + sw $a0 -320($fp) + b end_equal_25_ +_eq_false_25_: + li $a0 0 + sw $a0 -320($fp) +end_equal_25_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -324($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -324($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -324($fp) + lw $a0 12($a1) + sw $a0 -316($fp) + + # IF GOTO + lw $a0, -316($fp) + bnez $a0, _cil_label_LABEL_53 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -344($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -344($fp) + sw $a0, -312($fp) + + # GOTO + j _cil_label_LABEL_54 + +_cil_label_LABEL_53: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -348($fp) + sw $a0, -312($fp) + +_cil_label_LABEL_54: + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 -312($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # + + lw $a0, -36($fp) + lw $a1, -40($fp) + add $a0, $a0, $a1 + sw $a0, -32($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -368($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -368($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 76($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + lw $a2, -368($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -380($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -380($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + lw $a0 -380($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -376($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -372($fp) + lw $t1 -376($fp) + beq $t0 $zero _eq_false_26_ + beq $t1 $zero _eq_false_26_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_26 + li $a2 7 + beq $a0 $a2 _eq_int_bool_26 + li $a2 8 + bne $a0 $a2 _not_basic_type_26_ +_eq_str_26_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_26_ + beq $t3 $0 _eq_true_26_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_26_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_26_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_26_ + b _eq_true_26_ +_not_basic_type_26_: + bne $t0 $t1 _eq_false_26_ + b _eq_true_26_ +_eq_int_bool_26: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_26_ +_eq_true_26_: + li $a0 1 + sw $a0 -360($fp) + b end_equal_26_ +_eq_false_26_: + li $a0 0 + sw $a0 -360($fp) +end_equal_26_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + lw $a0 -360($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -364($fp) + lw $a0 12($a1) + sw $a0 -356($fp) + + # IF GOTO + lw $a0, -356($fp) + bnez $a0, _cil_label_LABEL_55 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -384($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -384($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -384($fp) + sw $a0, -352($fp) + + # GOTO + j _cil_label_LABEL_56 + +_cil_label_LABEL_55: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -388($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -388($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -388($fp) + sw $a0, -352($fp) + +_cil_label_LABEL_56: + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # GETATTR + lw $a1 -352($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # + + lw $a0, -20($fp) + lw $a1, -24($fp) + add $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -408($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -408($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 80($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -412($fp) + lw $a2, -408($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -420($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -420($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -416($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -416($fp) + lw $a0 -420($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -416($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -412($fp) + lw $t1 -416($fp) + beq $t0 $zero _eq_false_27_ + beq $t1 $zero _eq_false_27_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_27 + li $a2 7 + beq $a0 $a2 _eq_int_bool_27 + li $a2 8 + bne $a0 $a2 _not_basic_type_27_ +_eq_str_27_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_27_ + beq $t3 $0 _eq_true_27_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_27_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_27_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_27_ + b _eq_true_27_ +_not_basic_type_27_: + bne $t0 $t1 _eq_false_27_ + b _eq_true_27_ +_eq_int_bool_27: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_27_ +_eq_true_27_: + li $a0 1 + sw $a0 -400($fp) + b end_equal_27_ +_eq_false_27_: + li $a0 0 + sw $a0 -400($fp) +end_equal_27_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -404($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -404($fp) + lw $a0 -400($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -404($fp) + lw $a0 12($a1) + sw $a0 -396($fp) + + # IF GOTO + lw $a0, -396($fp) + bnez $a0, _cil_label_LABEL_57 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -424($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -424($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -424($fp) + sw $a0, -392($fp) + + # GOTO + j _cil_label_LABEL_58 + +_cil_label_LABEL_57: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -428($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -428($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -428($fp) + sw $a0, -392($fp) + +_cil_label_LABEL_58: + # GETATTR + lw $a1 -28($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # GETATTR + lw $a1 -392($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # + + lw $a0, -4($fp) + lw $a1, -8($fp) + add $a0, $a0, $a1 + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 432 + jr $ra + +function_CellularAutomaton_cell_at_next_evolution: + move $fp, $sp + subu $sp, $sp, 120 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 84($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_28_ + beq $t1 $zero _eq_false_28_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_28 + li $a2 7 + beq $a0 $a2 _eq_int_bool_28 + li $a2 8 + bne $a0 $a2 _not_basic_type_28_ +_eq_str_28_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_28_ + beq $t3 $0 _eq_true_28_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_28_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_28_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_28_ + b _eq_true_28_ +_not_basic_type_28_: + bne $t0 $t1 _eq_false_28_ + b _eq_true_28_ +_eq_int_bool_28: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_28_ +_eq_true_28_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_28_ +_eq_false_28_: + li $a0 0 + sw $a0 -8($fp) +end_equal_28_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_59 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 84($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 -48($fp) + lw $t1 -52($fp) + beq $t0 $zero _eq_false_29_ + beq $t1 $zero _eq_false_29_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_29 + li $a2 7 + beq $a0 $a2 _eq_int_bool_29 + li $a2 8 + bne $a0 $a2 _not_basic_type_29_ +_eq_str_29_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_29_ + beq $t3 $0 _eq_true_29_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_29_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_29_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_29_ + b _eq_true_29_ +_not_basic_type_29_: + bne $t0 $t1 _eq_false_29_ + b _eq_true_29_ +_eq_int_bool_29: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_29_ +_eq_true_29_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_29_ +_eq_false_29_: + li $a0 0 + sw $a0 -36($fp) +end_equal_29_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_61 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -56($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -56($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_62 + +_cil_label_LABEL_61: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + lw $a0 -92($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -88($fp) + la $a0, data_3 + sw $a0 16($a1) + + lw $t0 -84($fp) + lw $t1 -88($fp) + beq $t0 $zero _eq_false_30_ + beq $t1 $zero _eq_false_30_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_30 + li $a2 7 + beq $a0 $a2 _eq_int_bool_30 + li $a2 8 + bne $a0 $a2 _not_basic_type_30_ +_eq_str_30_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_30_ + beq $t3 $0 _eq_true_30_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_30_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_30_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_30_ + b _eq_true_30_ +_not_basic_type_30_: + bne $t0 $t1 _eq_false_30_ + b _eq_true_30_ +_eq_int_bool_30: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_30_ +_eq_true_30_: + li $a0 1 + sw $a0 -72($fp) + b end_equal_30_ +_eq_false_30_: + li $a0 0 + sw $a0 -72($fp) +end_equal_30_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -72($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -76($fp) + lw $a0 12($a1) + sw $a0 -68($fp) + + # IF GOTO + lw $a0, -68($fp) + bnez $a0, _cil_label_LABEL_63 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -96($fp) + la $a0, data_4 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -96($fp) + sw $a0, -64($fp) + + # GOTO + j _cil_label_LABEL_64 + +_cil_label_LABEL_63: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -104($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -104($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -104($fp) + sw $a0, -64($fp) + +_cil_label_LABEL_64: + # ASSIGN + lw $a0, -64($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_62: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_60 + +_cil_label_LABEL_59: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -116($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -116($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -112($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -112($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_60: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 120 + jr $ra + +function_CellularAutomaton_evolve: + move $fp, $sp + subu $sp, $sp, 76 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_65: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # < + lw $a1, -28($fp) + lw $a2, -32($fp) + slt $a0, $a1, $a2 + sw $a0, -24($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # IF GOTO + lw $a0, -20($fp) + bnez $a0, _cil_label_LABEL_66 + + # GOTO + j _cil_label_LABEL_67 + +_cil_label_LABEL_66: + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 88($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -44($fp) + sw $a0, -12($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_65 + +_cil_label_LABEL_67: + # ALLOCATE + la $v0 type_void + sw $v0 -16($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -12($fp) + sw $a0 24($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 76 + jr $ra + +function_CellularAutomaton_option: + move $fp, $sp + subu $sp, $sp, 992 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 24 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -28($fp) + la $a0, data_6 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 47 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_7 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 47 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -60($fp) + la $a0, data_8 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 9 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -76($fp) + la $a0, data_9 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -76($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -92($fp) + lw $a0 -96($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -92($fp) + la $a0, data_10 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -92($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -84($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -84($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + lw $a2, -84($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -108($fp) + lw $a0 -112($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -108($fp) + la $a0, data_11 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 27 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + lw $a0 -128($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -124($fp) + la $a0, data_12 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + li $a0, 24 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + lw $a0 -144($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -140($fp) + la $a0, data_13 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -140($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -132($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -132($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + lw $a2, -132($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + li $a0, 10 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + lw $a0 -160($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -156($fp) + la $a0, data_14 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -156($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -148($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -148($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + lw $a2, -148($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + lw $a0 -176($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -172($fp) + la $a0, data_15 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -172($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -164($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -164($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + lw $a2, -164($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -192($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -192($fp) + li $a0, 31 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -188($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -188($fp) + lw $a0 -192($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -188($fp) + la $a0, data_16 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -188($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -180($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -180($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + lw $a2, -180($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -208($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -208($fp) + li $a0, 17 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -204($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -204($fp) + lw $a0 -208($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -204($fp) + la $a0, data_17 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -204($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -196($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -196($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + lw $a2, -196($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + lw $a0 -224($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -220($fp) + la $a0, data_18 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -220($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -212($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -212($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + lw $a2, -212($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -236($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -236($fp) + lw $a0 -240($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -236($fp) + la $a0, data_19 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -236($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -228($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -228($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -232($fp) + lw $a2, -228($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -256($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -256($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -252($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -252($fp) + lw $a0 -256($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -252($fp) + la $a0, data_20 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -252($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -244($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -244($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + lw $a2, -244($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -268($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -268($fp) + lw $a0 -272($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -268($fp) + la $a0, data_21 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -268($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -260($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -260($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -264($fp) + lw $a2, -260($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -288($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -288($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -284($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -284($fp) + lw $a0 -288($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -284($fp) + la $a0, data_22 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -284($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -276($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -276($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -280($fp) + lw $a2, -276($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -300($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -300($fp) + lw $a0 -304($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -300($fp) + la $a0, data_23 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -300($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -292($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -292($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -296($fp) + lw $a2, -292($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -320($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -320($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -316($fp) + lw $a0 -320($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -316($fp) + la $a0, data_24 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -316($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -308($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -308($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -312($fp) + lw $a2, -308($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -332($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -332($fp) + lw $a0 -336($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -332($fp) + la $a0, data_25 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -332($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -324($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -324($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + lw $a2, -324($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -352($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -352($fp) + li $a0, 12 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -348($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -348($fp) + lw $a0 -352($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -348($fp) + la $a0, data_26 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -348($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -340($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -340($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -344($fp) + lw $a2, -340($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -368($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -368($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -364($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -364($fp) + lw $a0 -368($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -364($fp) + la $a0, data_27 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -364($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -356($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -356($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -360($fp) + lw $a2, -356($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -372($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -372($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + lw $a2, -372($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -376($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -392($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -392($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -388($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -388($fp) + lw $a0 -392($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -388($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -388($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -380($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -380($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -384($fp) + lw $a2, -380($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -412($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -412($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -412($fp) + beq $t0 $zero _eq_false_31_ + beq $t1 $zero _eq_false_31_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_31 + li $a2 7 + beq $a0 $a2 _eq_int_bool_31 + li $a2 8 + bne $a0 $a2 _not_basic_type_31_ +_eq_str_31_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_31_ + beq $t3 $0 _eq_true_31_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_31_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_31_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_31_ + b _eq_true_31_ +_not_basic_type_31_: + bne $t0 $t1 _eq_false_31_ + b _eq_true_31_ +_eq_int_bool_31: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_31_ +_eq_true_31_: + li $a0 1 + sw $a0 -404($fp) + b end_equal_31_ +_eq_false_31_: + li $a0 0 + sw $a0 -404($fp) +end_equal_31_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -408($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -408($fp) + lw $a0 -404($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -408($fp) + lw $a0 12($a1) + sw $a0 -400($fp) + + # IF GOTO + lw $a0, -400($fp) + bnez $a0, _cil_label_LABEL_68 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -432($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -432($fp) + li $a0, 2 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -432($fp) + beq $t0 $zero _eq_false_32_ + beq $t1 $zero _eq_false_32_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_32 + li $a2 7 + beq $a0 $a2 _eq_int_bool_32 + li $a2 8 + bne $a0 $a2 _not_basic_type_32_ +_eq_str_32_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_32_ + beq $t3 $0 _eq_true_32_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_32_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_32_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_32_ + b _eq_true_32_ +_not_basic_type_32_: + bne $t0 $t1 _eq_false_32_ + b _eq_true_32_ +_eq_int_bool_32: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_32_ +_eq_true_32_: + li $a0 1 + sw $a0 -424($fp) + b end_equal_32_ +_eq_false_32_: + li $a0 0 + sw $a0 -424($fp) +end_equal_32_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -428($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -428($fp) + lw $a0 -424($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -428($fp) + lw $a0 12($a1) + sw $a0 -420($fp) + + # IF GOTO + lw $a0, -420($fp) + bnez $a0, _cil_label_LABEL_70 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -452($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -452($fp) + li $a0, 3 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -452($fp) + beq $t0 $zero _eq_false_33_ + beq $t1 $zero _eq_false_33_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_33 + li $a2 7 + beq $a0 $a2 _eq_int_bool_33 + li $a2 8 + bne $a0 $a2 _not_basic_type_33_ +_eq_str_33_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_33_ + beq $t3 $0 _eq_true_33_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_33_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_33_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_33_ + b _eq_true_33_ +_not_basic_type_33_: + bne $t0 $t1 _eq_false_33_ + b _eq_true_33_ +_eq_int_bool_33: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_33_ +_eq_true_33_: + li $a0 1 + sw $a0 -444($fp) + b end_equal_33_ +_eq_false_33_: + li $a0 0 + sw $a0 -444($fp) +end_equal_33_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -448($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -448($fp) + lw $a0 -444($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -448($fp) + lw $a0 12($a1) + sw $a0 -440($fp) + + # IF GOTO + lw $a0, -440($fp) + bnez $a0, _cil_label_LABEL_72 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -472($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -472($fp) + li $a0, 4 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -472($fp) + beq $t0 $zero _eq_false_34_ + beq $t1 $zero _eq_false_34_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_34 + li $a2 7 + beq $a0 $a2 _eq_int_bool_34 + li $a2 8 + bne $a0 $a2 _not_basic_type_34_ +_eq_str_34_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_34_ + beq $t3 $0 _eq_true_34_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_34_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_34_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_34_ + b _eq_true_34_ +_not_basic_type_34_: + bne $t0 $t1 _eq_false_34_ + b _eq_true_34_ +_eq_int_bool_34: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_34_ +_eq_true_34_: + li $a0 1 + sw $a0 -464($fp) + b end_equal_34_ +_eq_false_34_: + li $a0 0 + sw $a0 -464($fp) +end_equal_34_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -468($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -468($fp) + lw $a0 -464($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -468($fp) + lw $a0 12($a1) + sw $a0 -460($fp) + + # IF GOTO + lw $a0, -460($fp) + bnez $a0, _cil_label_LABEL_74 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -492($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -492($fp) + li $a0, 5 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -492($fp) + beq $t0 $zero _eq_false_35_ + beq $t1 $zero _eq_false_35_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_35 + li $a2 7 + beq $a0 $a2 _eq_int_bool_35 + li $a2 8 + bne $a0 $a2 _not_basic_type_35_ +_eq_str_35_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_35_ + beq $t3 $0 _eq_true_35_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_35_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_35_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_35_ + b _eq_true_35_ +_not_basic_type_35_: + bne $t0 $t1 _eq_false_35_ + b _eq_true_35_ +_eq_int_bool_35: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_35_ +_eq_true_35_: + li $a0 1 + sw $a0 -484($fp) + b end_equal_35_ +_eq_false_35_: + li $a0 0 + sw $a0 -484($fp) +end_equal_35_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -488($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -488($fp) + lw $a0 -484($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -488($fp) + lw $a0 12($a1) + sw $a0 -480($fp) + + # IF GOTO + lw $a0, -480($fp) + bnez $a0, _cil_label_LABEL_76 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -512($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -512($fp) + li $a0, 6 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -512($fp) + beq $t0 $zero _eq_false_36_ + beq $t1 $zero _eq_false_36_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_36 + li $a2 7 + beq $a0 $a2 _eq_int_bool_36 + li $a2 8 + bne $a0 $a2 _not_basic_type_36_ +_eq_str_36_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_36_ + beq $t3 $0 _eq_true_36_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_36_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_36_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_36_ + b _eq_true_36_ +_not_basic_type_36_: + bne $t0 $t1 _eq_false_36_ + b _eq_true_36_ +_eq_int_bool_36: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_36_ +_eq_true_36_: + li $a0 1 + sw $a0 -504($fp) + b end_equal_36_ +_eq_false_36_: + li $a0 0 + sw $a0 -504($fp) +end_equal_36_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -508($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -508($fp) + lw $a0 -504($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -508($fp) + lw $a0 12($a1) + sw $a0 -500($fp) + + # IF GOTO + lw $a0, -500($fp) + bnez $a0, _cil_label_LABEL_78 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -532($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -532($fp) + li $a0, 7 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -532($fp) + beq $t0 $zero _eq_false_37_ + beq $t1 $zero _eq_false_37_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_37 + li $a2 7 + beq $a0 $a2 _eq_int_bool_37 + li $a2 8 + bne $a0 $a2 _not_basic_type_37_ +_eq_str_37_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_37_ + beq $t3 $0 _eq_true_37_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_37_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_37_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_37_ + b _eq_true_37_ +_not_basic_type_37_: + bne $t0 $t1 _eq_false_37_ + b _eq_true_37_ +_eq_int_bool_37: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_37_ +_eq_true_37_: + li $a0 1 + sw $a0 -524($fp) + b end_equal_37_ +_eq_false_37_: + li $a0 0 + sw $a0 -524($fp) +end_equal_37_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -528($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -528($fp) + lw $a0 -524($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -528($fp) + lw $a0 12($a1) + sw $a0 -520($fp) + + # IF GOTO + lw $a0, -520($fp) + bnez $a0, _cil_label_LABEL_80 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -552($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -552($fp) + li $a0, 8 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -552($fp) + beq $t0 $zero _eq_false_38_ + beq $t1 $zero _eq_false_38_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_38 + li $a2 7 + beq $a0 $a2 _eq_int_bool_38 + li $a2 8 + bne $a0 $a2 _not_basic_type_38_ +_eq_str_38_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_38_ + beq $t3 $0 _eq_true_38_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_38_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_38_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_38_ + b _eq_true_38_ +_not_basic_type_38_: + bne $t0 $t1 _eq_false_38_ + b _eq_true_38_ +_eq_int_bool_38: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_38_ +_eq_true_38_: + li $a0 1 + sw $a0 -544($fp) + b end_equal_38_ +_eq_false_38_: + li $a0 0 + sw $a0 -544($fp) +end_equal_38_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -548($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -548($fp) + lw $a0 -544($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -548($fp) + lw $a0 12($a1) + sw $a0 -540($fp) + + # IF GOTO + lw $a0, -540($fp) + bnez $a0, _cil_label_LABEL_82 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -572($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -572($fp) + li $a0, 9 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -572($fp) + beq $t0 $zero _eq_false_39_ + beq $t1 $zero _eq_false_39_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_39 + li $a2 7 + beq $a0 $a2 _eq_int_bool_39 + li $a2 8 + bne $a0 $a2 _not_basic_type_39_ +_eq_str_39_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_39_ + beq $t3 $0 _eq_true_39_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_39_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_39_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_39_ + b _eq_true_39_ +_not_basic_type_39_: + bne $t0 $t1 _eq_false_39_ + b _eq_true_39_ +_eq_int_bool_39: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_39_ +_eq_true_39_: + li $a0 1 + sw $a0 -564($fp) + b end_equal_39_ +_eq_false_39_: + li $a0 0 + sw $a0 -564($fp) +end_equal_39_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -568($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -568($fp) + lw $a0 -564($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -568($fp) + lw $a0 12($a1) + sw $a0 -560($fp) + + # IF GOTO + lw $a0, -560($fp) + bnez $a0, _cil_label_LABEL_84 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -592($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -592($fp) + li $a0, 10 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -592($fp) + beq $t0 $zero _eq_false_40_ + beq $t1 $zero _eq_false_40_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_40 + li $a2 7 + beq $a0 $a2 _eq_int_bool_40 + li $a2 8 + bne $a0 $a2 _not_basic_type_40_ +_eq_str_40_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_40_ + beq $t3 $0 _eq_true_40_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_40_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_40_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_40_ + b _eq_true_40_ +_not_basic_type_40_: + bne $t0 $t1 _eq_false_40_ + b _eq_true_40_ +_eq_int_bool_40: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_40_ +_eq_true_40_: + li $a0 1 + sw $a0 -584($fp) + b end_equal_40_ +_eq_false_40_: + li $a0 0 + sw $a0 -584($fp) +end_equal_40_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -588($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -588($fp) + lw $a0 -584($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -588($fp) + lw $a0 12($a1) + sw $a0 -580($fp) + + # IF GOTO + lw $a0, -580($fp) + bnez $a0, _cil_label_LABEL_86 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -612($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -612($fp) + li $a0, 11 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -612($fp) + beq $t0 $zero _eq_false_41_ + beq $t1 $zero _eq_false_41_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_41 + li $a2 7 + beq $a0 $a2 _eq_int_bool_41 + li $a2 8 + bne $a0 $a2 _not_basic_type_41_ +_eq_str_41_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_41_ + beq $t3 $0 _eq_true_41_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_41_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_41_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_41_ + b _eq_true_41_ +_not_basic_type_41_: + bne $t0 $t1 _eq_false_41_ + b _eq_true_41_ +_eq_int_bool_41: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_41_ +_eq_true_41_: + li $a0 1 + sw $a0 -604($fp) + b end_equal_41_ +_eq_false_41_: + li $a0 0 + sw $a0 -604($fp) +end_equal_41_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -608($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -608($fp) + lw $a0 -604($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -608($fp) + lw $a0 12($a1) + sw $a0 -600($fp) + + # IF GOTO + lw $a0, -600($fp) + bnez $a0, _cil_label_LABEL_88 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -632($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -632($fp) + li $a0, 12 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -632($fp) + beq $t0 $zero _eq_false_42_ + beq $t1 $zero _eq_false_42_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_42_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_42 + li $a2 7 + beq $a0 $a2 _eq_int_bool_42 + li $a2 8 + bne $a0 $a2 _not_basic_type_42_ +_eq_str_42_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_42_ + beq $t3 $0 _eq_true_42_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_42_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_42_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_42_ + b _eq_true_42_ +_not_basic_type_42_: + bne $t0 $t1 _eq_false_42_ + b _eq_true_42_ +_eq_int_bool_42: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_42_ +_eq_true_42_: + li $a0 1 + sw $a0 -624($fp) + b end_equal_42_ +_eq_false_42_: + li $a0 0 + sw $a0 -624($fp) +end_equal_42_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -628($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -628($fp) + lw $a0 -624($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -628($fp) + lw $a0 12($a1) + sw $a0 -620($fp) + + # IF GOTO + lw $a0, -620($fp) + bnez $a0, _cil_label_LABEL_90 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -652($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -652($fp) + li $a0, 13 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -652($fp) + beq $t0 $zero _eq_false_43_ + beq $t1 $zero _eq_false_43_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_43_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_43 + li $a2 7 + beq $a0 $a2 _eq_int_bool_43 + li $a2 8 + bne $a0 $a2 _not_basic_type_43_ +_eq_str_43_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_43_ + beq $t3 $0 _eq_true_43_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_43_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_43_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_43_ + b _eq_true_43_ +_not_basic_type_43_: + bne $t0 $t1 _eq_false_43_ + b _eq_true_43_ +_eq_int_bool_43: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_43_ +_eq_true_43_: + li $a0 1 + sw $a0 -644($fp) + b end_equal_43_ +_eq_false_43_: + li $a0 0 + sw $a0 -644($fp) +end_equal_43_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -648($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -648($fp) + lw $a0 -644($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -648($fp) + lw $a0 12($a1) + sw $a0 -640($fp) + + # IF GOTO + lw $a0, -640($fp) + bnez $a0, _cil_label_LABEL_92 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -672($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -672($fp) + li $a0, 14 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -672($fp) + beq $t0 $zero _eq_false_44_ + beq $t1 $zero _eq_false_44_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_44_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_44 + li $a2 7 + beq $a0 $a2 _eq_int_bool_44 + li $a2 8 + bne $a0 $a2 _not_basic_type_44_ +_eq_str_44_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_44_ + beq $t3 $0 _eq_true_44_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_44_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_44_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_44_ + b _eq_true_44_ +_not_basic_type_44_: + bne $t0 $t1 _eq_false_44_ + b _eq_true_44_ +_eq_int_bool_44: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_44_ +_eq_true_44_: + li $a0 1 + sw $a0 -664($fp) + b end_equal_44_ +_eq_false_44_: + li $a0 0 + sw $a0 -664($fp) +end_equal_44_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -668($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -668($fp) + lw $a0 -664($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -668($fp) + lw $a0 12($a1) + sw $a0 -660($fp) + + # IF GOTO + lw $a0, -660($fp) + bnez $a0, _cil_label_LABEL_94 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -692($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -692($fp) + li $a0, 15 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -692($fp) + beq $t0 $zero _eq_false_45_ + beq $t1 $zero _eq_false_45_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_45_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_45 + li $a2 7 + beq $a0 $a2 _eq_int_bool_45 + li $a2 8 + bne $a0 $a2 _not_basic_type_45_ +_eq_str_45_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_45_ + beq $t3 $0 _eq_true_45_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_45_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_45_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_45_ + b _eq_true_45_ +_not_basic_type_45_: + bne $t0 $t1 _eq_false_45_ + b _eq_true_45_ +_eq_int_bool_45: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_45_ +_eq_true_45_: + li $a0 1 + sw $a0 -684($fp) + b end_equal_45_ +_eq_false_45_: + li $a0 0 + sw $a0 -684($fp) +end_equal_45_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -688($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -688($fp) + lw $a0 -684($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -688($fp) + lw $a0 12($a1) + sw $a0 -680($fp) + + # IF GOTO + lw $a0, -680($fp) + bnez $a0, _cil_label_LABEL_96 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -712($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -712($fp) + li $a0, 16 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -712($fp) + beq $t0 $zero _eq_false_46_ + beq $t1 $zero _eq_false_46_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_46_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_46 + li $a2 7 + beq $a0 $a2 _eq_int_bool_46 + li $a2 8 + bne $a0 $a2 _not_basic_type_46_ +_eq_str_46_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_46_ + beq $t3 $0 _eq_true_46_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_46_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_46_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_46_ + b _eq_true_46_ +_not_basic_type_46_: + bne $t0 $t1 _eq_false_46_ + b _eq_true_46_ +_eq_int_bool_46: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_46_ +_eq_true_46_: + li $a0 1 + sw $a0 -704($fp) + b end_equal_46_ +_eq_false_46_: + li $a0 0 + sw $a0 -704($fp) +end_equal_46_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -708($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -708($fp) + lw $a0 -704($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -708($fp) + lw $a0 12($a1) + sw $a0 -700($fp) + + # IF GOTO + lw $a0, -700($fp) + bnez $a0, _cil_label_LABEL_98 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -732($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -732($fp) + li $a0, 17 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -732($fp) + beq $t0 $zero _eq_false_47_ + beq $t1 $zero _eq_false_47_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_47_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_47 + li $a2 7 + beq $a0 $a2 _eq_int_bool_47 + li $a2 8 + bne $a0 $a2 _not_basic_type_47_ +_eq_str_47_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_47_ + beq $t3 $0 _eq_true_47_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_47_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_47_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_47_ + b _eq_true_47_ +_not_basic_type_47_: + bne $t0 $t1 _eq_false_47_ + b _eq_true_47_ +_eq_int_bool_47: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_47_ +_eq_true_47_: + li $a0 1 + sw $a0 -724($fp) + b end_equal_47_ +_eq_false_47_: + li $a0 0 + sw $a0 -724($fp) +end_equal_47_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -728($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -728($fp) + lw $a0 -724($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -728($fp) + lw $a0 12($a1) + sw $a0 -720($fp) + + # IF GOTO + lw $a0, -720($fp) + bnez $a0, _cil_label_LABEL_100 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -752($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -752($fp) + li $a0, 18 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -752($fp) + beq $t0 $zero _eq_false_48_ + beq $t1 $zero _eq_false_48_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_48_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_48 + li $a2 7 + beq $a0 $a2 _eq_int_bool_48 + li $a2 8 + bne $a0 $a2 _not_basic_type_48_ +_eq_str_48_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_48_ + beq $t3 $0 _eq_true_48_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_48_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_48_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_48_ + b _eq_true_48_ +_not_basic_type_48_: + bne $t0 $t1 _eq_false_48_ + b _eq_true_48_ +_eq_int_bool_48: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_48_ +_eq_true_48_: + li $a0 1 + sw $a0 -744($fp) + b end_equal_48_ +_eq_false_48_: + li $a0 0 + sw $a0 -744($fp) +end_equal_48_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -748($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -748($fp) + lw $a0 -744($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -748($fp) + lw $a0 12($a1) + sw $a0 -740($fp) + + # IF GOTO + lw $a0, -740($fp) + bnez $a0, _cil_label_LABEL_102 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -772($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -772($fp) + li $a0, 19 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -772($fp) + beq $t0 $zero _eq_false_49_ + beq $t1 $zero _eq_false_49_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_49_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_49 + li $a2 7 + beq $a0 $a2 _eq_int_bool_49 + li $a2 8 + bne $a0 $a2 _not_basic_type_49_ +_eq_str_49_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_49_ + beq $t3 $0 _eq_true_49_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_49_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_49_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_49_ + b _eq_true_49_ +_not_basic_type_49_: + bne $t0 $t1 _eq_false_49_ + b _eq_true_49_ +_eq_int_bool_49: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_49_ +_eq_true_49_: + li $a0 1 + sw $a0 -764($fp) + b end_equal_49_ +_eq_false_49_: + li $a0 0 + sw $a0 -764($fp) +end_equal_49_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -768($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -768($fp) + lw $a0 -764($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -768($fp) + lw $a0 12($a1) + sw $a0 -760($fp) + + # IF GOTO + lw $a0, -760($fp) + bnez $a0, _cil_label_LABEL_104 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -792($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -792($fp) + li $a0, 20 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -792($fp) + beq $t0 $zero _eq_false_50_ + beq $t1 $zero _eq_false_50_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_50_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_50 + li $a2 7 + beq $a0 $a2 _eq_int_bool_50 + li $a2 8 + bne $a0 $a2 _not_basic_type_50_ +_eq_str_50_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_50_ + beq $t3 $0 _eq_true_50_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_50_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_50_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_50_ + b _eq_true_50_ +_not_basic_type_50_: + bne $t0 $t1 _eq_false_50_ + b _eq_true_50_ +_eq_int_bool_50: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_50_ +_eq_true_50_: + li $a0 1 + sw $a0 -784($fp) + b end_equal_50_ +_eq_false_50_: + li $a0 0 + sw $a0 -784($fp) +end_equal_50_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -788($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -788($fp) + lw $a0 -784($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -788($fp) + lw $a0 12($a1) + sw $a0 -780($fp) + + # IF GOTO + lw $a0, -780($fp) + bnez $a0, _cil_label_LABEL_106 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -812($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -812($fp) + li $a0, 21 + sw $a0 12($a1) + + lw $t0 0($fp) + lw $t1 -812($fp) + beq $t0 $zero _eq_false_51_ + beq $t1 $zero _eq_false_51_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_51_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_51 + li $a2 7 + beq $a0 $a2 _eq_int_bool_51 + li $a2 8 + bne $a0 $a2 _not_basic_type_51_ +_eq_str_51_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_51_ + beq $t3 $0 _eq_true_51_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_51_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_51_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_51_ + b _eq_true_51_ +_not_basic_type_51_: + bne $t0 $t1 _eq_false_51_ + b _eq_true_51_ +_eq_int_bool_51: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_51_ +_eq_true_51_: + li $a0 1 + sw $a0 -804($fp) + b end_equal_51_ +_eq_false_51_: + li $a0 0 + sw $a0 -804($fp) +end_equal_51_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -808($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -808($fp) + lw $a0 -804($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -808($fp) + lw $a0 12($a1) + sw $a0 -800($fp) + + # IF GOTO + lw $a0, -800($fp) + bnez $a0, _cil_label_LABEL_108 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -820($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -820($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -816($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -816($fp) + lw $a0 -820($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -816($fp) + la $a0, data_28 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -816($fp) + sw $a0, -796($fp) + + # GOTO + j _cil_label_LABEL_109 + +_cil_label_LABEL_108: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -828($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -828($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -824($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -824($fp) + lw $a0 -828($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -824($fp) + la $a0, data_29 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -824($fp) + sw $a0, -796($fp) + +_cil_label_LABEL_109: + # ASSIGN + lw $a0, -796($fp) + sw $a0, -776($fp) + + # GOTO + j _cil_label_LABEL_107 + +_cil_label_LABEL_106: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -836($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -836($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -832($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -832($fp) + lw $a0 -836($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -832($fp) + la $a0, data_30 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -832($fp) + sw $a0, -776($fp) + +_cil_label_LABEL_107: + # ASSIGN + lw $a0, -776($fp) + sw $a0, -756($fp) + + # GOTO + j _cil_label_LABEL_105 + +_cil_label_LABEL_104: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -844($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -844($fp) + li $a0, 16 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -840($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -840($fp) + lw $a0 -844($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -840($fp) + la $a0, data_31 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -840($fp) + sw $a0, -756($fp) + +_cil_label_LABEL_105: + # ASSIGN + lw $a0, -756($fp) + sw $a0, -736($fp) + + # GOTO + j _cil_label_LABEL_103 + +_cil_label_LABEL_102: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -852($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -852($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -848($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -848($fp) + lw $a0 -852($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -848($fp) + la $a0, data_32 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -848($fp) + sw $a0, -736($fp) + +_cil_label_LABEL_103: + # ASSIGN + lw $a0, -736($fp) + sw $a0, -716($fp) + + # GOTO + j _cil_label_LABEL_101 + +_cil_label_LABEL_100: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -860($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -860($fp) + li $a0, 28 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -856($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -856($fp) + lw $a0 -860($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -856($fp) + la $a0, data_33 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -856($fp) + sw $a0, -716($fp) + +_cil_label_LABEL_101: + # ASSIGN + lw $a0, -716($fp) + sw $a0, -696($fp) + + # GOTO + j _cil_label_LABEL_99 + +_cil_label_LABEL_98: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -868($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -868($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -864($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -864($fp) + lw $a0 -868($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -864($fp) + la $a0, data_34 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -864($fp) + sw $a0, -696($fp) + +_cil_label_LABEL_99: + # ASSIGN + lw $a0, -696($fp) + sw $a0, -676($fp) + + # GOTO + j _cil_label_LABEL_97 + +_cil_label_LABEL_96: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -876($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -876($fp) + li $a0, 21 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -872($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -872($fp) + lw $a0 -876($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -872($fp) + la $a0, data_35 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -872($fp) + sw $a0, -676($fp) + +_cil_label_LABEL_97: + # ASSIGN + lw $a0, -676($fp) + sw $a0, -656($fp) + + # GOTO + j _cil_label_LABEL_95 + +_cil_label_LABEL_94: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -884($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -884($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -880($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -880($fp) + lw $a0 -884($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -880($fp) + la $a0, data_36 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -880($fp) + sw $a0, -656($fp) + +_cil_label_LABEL_95: + # ASSIGN + lw $a0, -656($fp) + sw $a0, -636($fp) + + # GOTO + j _cil_label_LABEL_93 + +_cil_label_LABEL_92: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -892($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -892($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -888($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -888($fp) + lw $a0 -892($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -888($fp) + la $a0, data_37 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -888($fp) + sw $a0, -636($fp) + +_cil_label_LABEL_93: + # ASSIGN + lw $a0, -636($fp) + sw $a0, -616($fp) + + # GOTO + j _cil_label_LABEL_91 + +_cil_label_LABEL_90: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -900($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -900($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -896($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -896($fp) + lw $a0 -900($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -896($fp) + la $a0, data_38 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -896($fp) + sw $a0, -616($fp) + +_cil_label_LABEL_91: + # ASSIGN + lw $a0, -616($fp) + sw $a0, -596($fp) + + # GOTO + j _cil_label_LABEL_89 + +_cil_label_LABEL_88: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -908($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -908($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -904($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -904($fp) + lw $a0 -908($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -904($fp) + la $a0, data_39 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -904($fp) + sw $a0, -596($fp) + +_cil_label_LABEL_89: + # ASSIGN + lw $a0, -596($fp) + sw $a0, -576($fp) + + # GOTO + j _cil_label_LABEL_87 + +_cil_label_LABEL_86: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -916($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -916($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -912($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -912($fp) + lw $a0 -916($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -912($fp) + la $a0, data_40 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -912($fp) + sw $a0, -576($fp) + +_cil_label_LABEL_87: + # ASSIGN + lw $a0, -576($fp) + sw $a0, -556($fp) + + # GOTO + j _cil_label_LABEL_85 + +_cil_label_LABEL_84: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -924($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -924($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -920($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -920($fp) + lw $a0 -924($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -920($fp) + la $a0, data_41 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -920($fp) + sw $a0, -556($fp) + +_cil_label_LABEL_85: + # ASSIGN + lw $a0, -556($fp) + sw $a0, -536($fp) + + # GOTO + j _cil_label_LABEL_83 + +_cil_label_LABEL_82: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -932($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -932($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -928($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -928($fp) + lw $a0 -932($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -928($fp) + la $a0, data_42 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -928($fp) + sw $a0, -536($fp) + +_cil_label_LABEL_83: + # ASSIGN + lw $a0, -536($fp) + sw $a0, -516($fp) + + # GOTO + j _cil_label_LABEL_81 + +_cil_label_LABEL_80: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -940($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -940($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -936($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -936($fp) + lw $a0 -940($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -936($fp) + la $a0, data_43 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -936($fp) + sw $a0, -516($fp) + +_cil_label_LABEL_81: + # ASSIGN + lw $a0, -516($fp) + sw $a0, -496($fp) + + # GOTO + j _cil_label_LABEL_79 + +_cil_label_LABEL_78: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -948($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -948($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -944($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -944($fp) + lw $a0 -948($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -944($fp) + la $a0, data_44 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -944($fp) + sw $a0, -496($fp) + +_cil_label_LABEL_79: + # ASSIGN + lw $a0, -496($fp) + sw $a0, -476($fp) + + # GOTO + j _cil_label_LABEL_77 + +_cil_label_LABEL_76: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -956($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -956($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -952($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -952($fp) + lw $a0 -956($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -952($fp) + la $a0, data_45 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -952($fp) + sw $a0, -476($fp) + +_cil_label_LABEL_77: + # ASSIGN + lw $a0, -476($fp) + sw $a0, -456($fp) + + # GOTO + j _cil_label_LABEL_75 + +_cil_label_LABEL_74: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -964($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -964($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -960($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -960($fp) + lw $a0 -964($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -960($fp) + la $a0, data_46 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -960($fp) + sw $a0, -456($fp) + +_cil_label_LABEL_75: + # ASSIGN + lw $a0, -456($fp) + sw $a0, -436($fp) + + # GOTO + j _cil_label_LABEL_73 + +_cil_label_LABEL_72: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -972($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -972($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -968($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -968($fp) + lw $a0 -972($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -968($fp) + la $a0, data_47 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -968($fp) + sw $a0, -436($fp) + +_cil_label_LABEL_73: + # ASSIGN + lw $a0, -436($fp) + sw $a0, -416($fp) + + # GOTO + j _cil_label_LABEL_71 + +_cil_label_LABEL_70: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -980($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -980($fp) + li $a0, 25 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -976($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -976($fp) + lw $a0 -980($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -976($fp) + la $a0, data_48 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -976($fp) + sw $a0, -416($fp) + +_cil_label_LABEL_71: + # ASSIGN + lw $a0, -416($fp) + sw $a0, -396($fp) + + # GOTO + j _cil_label_LABEL_69 + +_cil_label_LABEL_68: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -988($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -988($fp) + li $a0, 20 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -984($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -984($fp) + lw $a0 -988($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -984($fp) + la $a0, data_49 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -984($fp) + sw $a0, -396($fp) + +_cil_label_LABEL_69: + # RETURN + lw $v0, -396($fp) + addiu $sp, $sp, 992 + jr $ra + +function_CellularAutomaton_prompt: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 54 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_50 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 49 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -28($fp) + la $a0, data_51 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -40($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -52($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -76($fp) + la $a0, data_52 + sw $a0 16($a1) + + lw $t0 0($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_52_ + beq $t1 $zero _eq_false_52_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_52_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_52 + li $a2 7 + beq $a0 $a2 _eq_int_bool_52 + li $a2 8 + bne $a0 $a2 _not_basic_type_52_ +_eq_str_52_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_52_ + beq $t3 $0 _eq_true_52_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_52_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_52_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_52_ + b _eq_true_52_ +_not_basic_type_52_: + bne $t0 $t1 _eq_false_52_ + b _eq_true_52_ +_eq_int_bool_52: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_52_ +_eq_true_52_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_52_ +_eq_false_52_: + li $a0 0 + sw $a0 -68($fp) +end_equal_52_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_110 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_111 + +_cil_label_LABEL_110: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -88($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_111: + # RETURN + lw $v0, -60($fp) + addiu $sp, $sp, 92 + jr $ra + +function_CellularAutomaton_prompt2: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 2 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -12($fp) + la $a0, data_53 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 48 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -28($fp) + la $a0, data_54 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 49 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_55 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -56($fp) + sw $a0, 0($fp) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -76($fp) + la $a0, data_56 + sw $a0 16($a1) + + lw $t0 0($fp) + lw $t1 -76($fp) + beq $t0 $zero _eq_false_53_ + beq $t1 $zero _eq_false_53_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_53_ + li $a2 6 + beq $a0 $a2 _eq_int_bool_53 + li $a2 7 + beq $a0 $a2 _eq_int_bool_53 + li $a2 8 + bne $a0 $a2 _not_basic_type_53_ +_eq_str_53_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_53_ + beq $t3 $0 _eq_true_53_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_53_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_53_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_53_ + b _eq_true_53_ +_not_basic_type_53_: + bne $t0 $t1 _eq_false_53_ + b _eq_true_53_ +_eq_int_bool_53: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_53_ +_eq_true_53_: + li $a0 1 + sw $a0 -68($fp) + b end_equal_53_ +_eq_false_53_: + li $a0 0 + sw $a0 -68($fp) +end_equal_53_: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # IF GOTO + lw $a0, -64($fp) + bnez $a0, _cil_label_LABEL_112 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -84($fp) + sw $a0, -60($fp) + + # GOTO + j _cil_label_LABEL_113 + +_cil_label_LABEL_112: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -88($fp) + sw $a0, -60($fp) + +_cil_label_LABEL_113: + # RETURN + lw $v0, -60($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_CellularAutomaton__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 28($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 148 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Bool__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_String__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_57 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 47 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -32($fp) + la $a0, data_58 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_114: + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 104($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -44($fp) + + # IF GOTO + lw $a0, -44($fp) + bnez $a0, _cil_label_LABEL_115 + + # GOTO + j _cil_label_LABEL_116 + +_cil_label_LABEL_115: + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -56($fp) + sw $a0, 0($fp) + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 96($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -64($fp) + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_CellularAutomaton__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -68($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -80($fp) + sw $a0 28($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 28($a1) + sw $a0 -84($fp) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -84($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + +_cil_label_LABEL_117: + # GETATTR + lw $a1 0($fp) + lw $a0 12($a1) + sw $a0 -100($fp) + + # IF GOTO + lw $a0, -100($fp) + bnez $a0, _cil_label_LABEL_118 + + # GOTO + j _cil_label_LABEL_119 + +_cil_label_LABEL_118: + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -112($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -112($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 100($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + lw $a2, -112($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -116($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # IF GOTO + lw $a0, -108($fp) + bnez $a0, _cil_label_LABEL_120 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, 0($fp) + + # ASSIGN + lw $a0, -120($fp) + sw $a0, -104($fp) + + # GOTO + j _cil_label_LABEL_121 + +_cil_label_LABEL_120: + # GETATTR + lw $a1 12($fp) + lw $a0 28($a1) + sw $a0 -124($fp) + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -124($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 92($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 28($a1) + sw $a0 -136($fp) + + # PUSHPARAM + lw $a0, -136($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -136($fp) + lw $a0 0($a1) + sw $a0 -140($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -140($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + lw $a2, -140($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -144($fp) + sw $a0, -104($fp) + +_cil_label_LABEL_121: + # GOTO + j _cil_label_LABEL_117 + +_cil_label_LABEL_119: + # ALLOCATE + la $v0 type_void + sw $v0 -96($fp) + + # GOTO + j _cil_label_LABEL_114 + +_cil_label_LABEL_116: + # ALLOCATE + la $v0 type_void + sw $v0 -40($fp) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 148 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/list.mips b/tests/codegen/list.mips new file mode 100644 index 00000000..f76ec38a --- /dev/null +++ b/tests/codegen/list.mips @@ -0,0 +1,2616 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz " " + data_2: .align 2 + .asciiz "\n" + data_3: .align 2 + .asciiz "Abort called from class List\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_List: .align 2 + .asciiz "List" + classname_Cons: .align 2 + .asciiz "Cons" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 36 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_List + sw $t1 28($s1) + la $t1 classname_Cons + sw $t1 32($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 72 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type List + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 64($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_print_list + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type List + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_List_isNil + sw $t1 12($v0) + la $t1 function_List_head + sw $t1 16($v0) + la $t1 function_List_tail + sw $t1 20($v0) + la $t1 function_List_cons + sw $t1 24($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Cons_isNil + sw $t1 12($v0) + la $t1 function_Cons_head + sw $t1 16($v0) + la $t1 function_Cons_tail + sw $t1 20($v0) + la $t1 function_List_cons + sw $t1 24($v0) + la $t1 function_Cons_init + sw $t1 28($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 36 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 7 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_print_list: + move $fp, $sp + subu $sp, $sp, 80 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 2 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 3 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 4 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 5 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -88($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # - + li $a0 1 + lw $a1, -76($fp) + sub $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_3 + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -112($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -120($fp) + sw $a0 12($a1) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_4: + # ALLOCATE + la $v0 type_void + sw $v0 -68($fp) + + # RETURN + lw $v0, -68($fp) + addiu $sp, $sp, 124 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_List__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_List_head: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_List_tail: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_List_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_head: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_tail: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/list.s b/tests/codegen/list.s new file mode 100644 index 00000000..7f6f3824 --- /dev/null +++ b/tests/codegen/list.s @@ -0,0 +1,2389 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz " " + data_2: .align 2 + .asciiz "\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_List: .align 2 + .asciiz "List" + classname_Cons: .align 2 + .asciiz "Cons" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 36 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_List + sw $t1 28($s1) + la $t1 classname_Cons + sw $t1 32($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 72 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type List + li $a0 12 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 64($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_print_list + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type List + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_List_isNil + sw $t1 12($v0) + la $t1 function_List_head + sw $t1 16($v0) + la $t1 function_List_tail + sw $t1 20($v0) + la $t1 function_List_cons + sw $t1 24($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 44 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_List_isNil + sw $t1 12($v0) + la $t1 function_List_head + sw $t1 16($v0) + la $t1 function_List_tail + sw $t1 20($v0) + la $t1 function_List_cons + sw $t1 24($v0) + la $t1 function_Cons_isNil + sw $t1 28($v0) + la $t1 function_Cons_head + sw $t1 32($v0) + la $t1 function_Cons_tail + sw $t1 36($v0) + la $t1 function_Cons_init + sw $t1 40($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 36 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 7 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_print_list: + move $fp, $sp + subu $sp, $sp, 80 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -40($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -52($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 124 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 2 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 3 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -24($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 4 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 5 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -60($fp) + sw $a0 12($a1) + +_cil_label_LABEL_2: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -88($fp) + lw $a0 0($a1) + sw $a0 -92($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -92($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + lw $a2, -92($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -96($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # - + li $a0 1 + lw $a1, -76($fp) + sub $a0, $a0, $a1 + sw $a0, -80($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -80($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -84($fp) + lw $a0 12($a1) + sw $a0 -72($fp) + + # IF GOTO + lw $a0, -72($fp) + bnez $a0, _cil_label_LABEL_3 + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -100($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -100($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -104($fp) + lw $a2, -100($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -112($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -120($fp) + sw $a0 12($a1) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_4: + # ALLOCATE + la $v0 type_void + sw $v0 -68($fp) + + # RETURN + lw $v0, -68($fp) + addiu $sp, $sp, 124 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_List_head: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_List_tail: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_head: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_tail: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/new_complex.mips b/tests/codegen/new_complex.mips new file mode 100644 index 00000000..c21e4517 --- /dev/null +++ b/tests/codegen/new_complex.mips @@ -0,0 +1,3371 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "=(\n" + data_2: .align 2 + .asciiz "=)\n" + data_3: .align 2 + .asciiz "+" + data_4: .align 2 + .asciiz "I" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Complex: .align 2 + .asciiz "Complex" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Complex + sw $t1 16($s1) + la $t1 classname_Int + sw $t1 20($s1) + la $t1 classname_Bool + sw $t1 24($s1) + la $t1 classname_String + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Complex + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Complex + li $a0 60 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Complex_init + sw $t1 28($v0) + la $t1 function_Complex_print + sw $t1 32($v0) + la $t1 function_Complex_reflect_0 + sw $t1 36($v0) + la $t1 function_Complex_reflect_X + sw $t1 40($v0) + la $t1 function_Complex_reflect_Y + sw $t1 44($v0) + la $t1 function_Complex_equal + sw $t1 48($v0) + la $t1 function_Complex_x_value + sw $t1 52($v0) + la $t1 function_Complex_y_value + sw $t1 56($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 160 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Complex__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -44($fp) + lw $t1 -52($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + beq $a0 $a2 _eq_int_bool_1 + li $a2 7 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_1: + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -96($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -96($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + lw $a2, -96($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -100($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -120($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -120($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + lw $a2, -120($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -108($fp) + lw $a0 0($a1) + sw $a0 -112($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -112($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + lw $a2, -112($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -116($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # IF GOTO + lw $a0, -92($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -136($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -132($fp) + sw $a0, -88($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -156($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -152($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -152($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -148($fp) + sw $a0, -88($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, -88($fp) + addiu $sp, $sp, 160 + jr $ra + +function_Complex__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Complex_init: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + lw $t0 -8($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + beq $a0 $a2 _eq_int_bool_2 + li $a2 7 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 0($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 0($fp) +end_equal_2_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -20($fp) + + lw $t0 -20($fp) + lw $t1 20($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + beq $a0 $a2 _eq_int_bool_3 + li $a2 7 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -12($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -12($fp) +end_equal_3_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Complex_print: + move $fp, $sp + subu $sp, $sp, 92 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -16($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + beq $a0 $a2 _eq_int_bool_4 + li $a2 7 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -8($fp) +end_equal_4_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -40($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_5: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Complex_reflect_0: + move $fp, $sp + subu $sp, $sp, 56 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + beq $a0 $a2 _eq_int_bool_5 + li $a2 7 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 0($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 0($fp) +end_equal_5_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # - + li $a0 0 + lw $a1, -40($fp) + sub $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + lw $t0 -36($fp) + lw $t1 -48($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + beq $a0 $a2 _eq_int_bool_6 + li $a2 7 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -28($fp) +end_equal_6_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Complex_reflect_X: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + beq $a0 $a2 _eq_int_bool_7 + li $a2 7 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 0($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 0($fp) +end_equal_7_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_reflect_Y: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + beq $a0 $a2 _eq_int_bool_8 + li $a2 7 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 0($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 0($fp) +end_equal_8_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_equal: + move $fp, $sp + subu $sp, $sp, 68 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -16($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + beq $a0 $a2 _eq_int_bool_9 + li $a2 7 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -8($fp) +end_equal_9_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -48($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -48($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + beq $a0 $a2 _eq_int_bool_10 + li $a2 7 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -40($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -40($fp) +end_equal_10_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -32($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -64($fp) + sw $a0, -32($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -32($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_7: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 68 + jr $ra + +function_Complex_x_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Complex_y_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/new_complex.s b/tests/codegen/new_complex.s new file mode 100644 index 00000000..78dca231 --- /dev/null +++ b/tests/codegen/new_complex.s @@ -0,0 +1,3384 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "=(\n" + data_2: .align 2 + .asciiz "=)\n" + data_3: .align 2 + .asciiz "+" + data_4: .align 2 + .asciiz "I" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Complex: .align 2 + .asciiz "Complex" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Complex + sw $t1 16($s1) + la $t1 classname_Int + sw $t1 20($s1) + la $t1 classname_Bool + sw $t1 24($s1) + la $t1 classname_String + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Complex + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Complex + li $a0 60 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Complex_init + sw $t1 28($v0) + la $t1 function_Complex_print + sw $t1 32($v0) + la $t1 function_Complex_reflect_0 + sw $t1 36($v0) + la $t1 function_Complex_reflect_X + sw $t1 40($v0) + la $t1 function_Complex_reflect_Y + sw $t1 44($v0) + la $t1 function_Complex_equal + sw $t1 48($v0) + la $t1 function_Complex_x_value + sw $t1 52($v0) + la $t1 function_Complex_y_value + sw $t1 56($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 160 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Complex__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -44($fp) + lw $t1 -52($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + beq $a0 $a2 _eq_int_bool_1 + li $a2 7 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -32($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -32($fp) +end_equal_1_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + lw $a0 -32($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -36($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # IF GOTO + lw $a0, -28($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -24($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -24($fp) + +_cil_label_LABEL_1: + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -96($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -96($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + lw $a2, -96($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -100($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -100($fp) + lw $a0 0($a1) + sw $a0 -104($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -104($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -108($fp) + lw $a2, -104($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -12($fp) + lw $a0 0($a1) + sw $a0 -120($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -120($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 36($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + lw $a2, -120($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -124($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -108($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -108($fp) + lw $a0 0($a1) + sw $a0 -112($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -112($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -116($fp) + lw $a2, -112($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -116($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # IF GOTO + lw $a0, -92($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -140($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -140($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -136($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -136($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -136($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -128($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -128($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -132($fp) + lw $a2, -128($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -132($fp) + sw $a0, -88($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -156($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -156($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -152($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -152($fp) + lw $a0 -156($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -152($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -152($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -144($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -144($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -148($fp) + lw $a2, -144($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -148($fp) + sw $a0, -88($fp) + +_cil_label_LABEL_3: + # RETURN + lw $v0, -88($fp) + addiu $sp, $sp, 160 + jr $ra + +function_Complex__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Complex_init: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + lw $t0 -8($fp) + lw $t1 16($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + beq $a0 $a2 _eq_int_bool_2 + li $a2 7 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 0($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 0($fp) +end_equal_2_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -20($fp) + + lw $t0 -20($fp) + lw $t1 20($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + beq $a0 $a2 _eq_int_bool_3 + li $a2 7 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -12($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -12($fp) +end_equal_3_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Complex_print: + move $fp, $sp + subu $sp, $sp, 92 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -16($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_4_ + beq $t1 $zero _eq_false_4_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_4 + li $a2 6 + beq $a0 $a2 _eq_int_bool_4 + li $a2 7 + bne $a0 $a2 _not_basic_type_4_ +_eq_str_4_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_4_ + beq $t3 $0 _eq_true_4_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_4_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_4_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_4_ + b _eq_true_4_ +_not_basic_type_4_: + bne $t0 $t1 _eq_false_4_ + b _eq_true_4_ +_eq_int_bool_4: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_4_ +_eq_true_4_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_4_ +_eq_false_4_: + li $a0 0 + sw $a0 -8($fp) +end_equal_4_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -44($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -40($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -40($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -76($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + lw $a0 -76($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -72($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -64($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -64($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + lw $a2, -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -68($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -88($fp) + + # PUSHPARAM + lw $a0, -88($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -80($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -80($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + lw $a2, -80($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -84($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_5: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Complex_reflect_0: + move $fp, $sp + subu $sp, $sp, 56 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_5_ + beq $t1 $zero _eq_false_5_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_5 + li $a2 6 + beq $a0 $a2 _eq_int_bool_5 + li $a2 7 + bne $a0 $a2 _not_basic_type_5_ +_eq_str_5_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_5_ + beq $t3 $0 _eq_true_5_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_5_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_5_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_5_ + b _eq_true_5_ +_not_basic_type_5_: + bne $t0 $t1 _eq_false_5_ + b _eq_true_5_ +_eq_int_bool_5: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_5_ +_eq_true_5_: + li $a0 1 + sw $a0 0($fp) + b end_equal_5_ +_eq_false_5_: + li $a0 0 + sw $a0 0($fp) +end_equal_5_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -36($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -52($fp) + + # GETATTR + lw $a1 -52($fp) + lw $a0 12($a1) + sw $a0 -40($fp) + + # - + li $a0 0 + lw $a1, -40($fp) + sub $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -48($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + lw $t0 -36($fp) + lw $t1 -48($fp) + beq $t0 $zero _eq_false_6_ + beq $t1 $zero _eq_false_6_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_6 + li $a2 6 + beq $a0 $a2 _eq_int_bool_6 + li $a2 7 + bne $a0 $a2 _not_basic_type_6_ +_eq_str_6_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_6_ + beq $t3 $0 _eq_true_6_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_6_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_6_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_6_ + b _eq_true_6_ +_not_basic_type_6_: + bne $t0 $t1 _eq_false_6_ + b _eq_true_6_ +_eq_int_bool_6: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_6_ +_eq_true_6_: + li $a0 1 + sw $a0 -28($fp) + b end_equal_6_ +_eq_false_6_: + li $a0 0 + sw $a0 -28($fp) +end_equal_6_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Complex_reflect_X: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_7_ + beq $t1 $zero _eq_false_7_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_7 + li $a2 6 + beq $a0 $a2 _eq_int_bool_7 + li $a2 7 + bne $a0 $a2 _not_basic_type_7_ +_eq_str_7_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_7_ + beq $t3 $0 _eq_true_7_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_7_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_7_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_7_ + b _eq_true_7_ +_not_basic_type_7_: + bne $t0 $t1 _eq_false_7_ + b _eq_true_7_ +_eq_int_bool_7: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_7_ +_eq_true_7_: + li $a0 1 + sw $a0 0($fp) + b end_equal_7_ +_eq_false_7_: + li $a0 0 + sw $a0 0($fp) +end_equal_7_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_reflect_Y: + move $fp, $sp + subu $sp, $sp, 28 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # - + li $a0 0 + lw $a1, -12($fp) + sub $a0, $a0, $a1 + sw $a0, -16($fp) + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + lw $t0 -8($fp) + lw $t1 -20($fp) + beq $t0 $zero _eq_false_8_ + beq $t1 $zero _eq_false_8_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_8 + li $a2 6 + beq $a0 $a2 _eq_int_bool_8 + li $a2 7 + bne $a0 $a2 _not_basic_type_8_ +_eq_str_8_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_8_ + beq $t3 $0 _eq_true_8_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_8_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_8_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_8_ + b _eq_true_8_ +_not_basic_type_8_: + bne $t0 $t1 _eq_false_8_ + b _eq_true_8_ +_eq_int_bool_8: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_8_ +_eq_true_8_: + li $a0 1 + sw $a0 0($fp) + b end_equal_8_ +_eq_false_8_: + li $a0 0 + sw $a0 0($fp) +end_equal_8_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 28 + jr $ra + +function_Complex_equal: + move $fp, $sp + subu $sp, $sp, 68 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -16($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_9_ + beq $t1 $zero _eq_false_9_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_9 + li $a2 6 + beq $a0 $a2 _eq_int_bool_9 + li $a2 7 + bne $a0 $a2 _not_basic_type_9_ +_eq_str_9_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_9_ + beq $t3 $0 _eq_true_9_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_9_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_9_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_9_ + b _eq_true_9_ +_not_basic_type_9_: + bne $t0 $t1 _eq_false_9_ + b _eq_true_9_ +_eq_int_bool_9: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_9_ +_eq_true_9_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_9_ +_eq_false_9_: + li $a0 0 + sw $a0 -8($fp) +end_equal_9_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -48($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -48($fp) + lw $t1 -56($fp) + beq $t0 $zero _eq_false_10_ + beq $t1 $zero _eq_false_10_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + li $a2 5 + beq $a0 $a2 _eq_int_bool_10 + li $a2 6 + beq $a0 $a2 _eq_int_bool_10 + li $a2 7 + bne $a0 $a2 _not_basic_type_10_ +_eq_str_10_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_10_ + beq $t3 $0 _eq_true_10_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_10_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_10_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_10_ + b _eq_true_10_ +_not_basic_type_10_: + bne $t0 $t1 _eq_false_10_ + b _eq_true_10_ +_eq_int_bool_10: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_10_ +_eq_true_10_: + li $a0 1 + sw $a0 -40($fp) + b end_equal_10_ +_eq_false_10_: + li $a0 0 + sw $a0 -40($fp) +end_equal_10_: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -44($fp) + lw $a0 -40($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -60($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -32($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -64($fp) + sw $a0, -32($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -32($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_7: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 68 + jr $ra + +function_Complex_x_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Complex_y_value: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/palindrome.mips b/tests/codegen/palindrome.mips new file mode 100644 index 00000000..70a24479 --- /dev/null +++ b/tests/codegen/palindrome.mips @@ -0,0 +1,2358 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "enter a string\n" + data_2: .align 2 + .asciiz "that was not a palindrome\n" + data_3: .align 2 + .asciiz "that was a palindrome\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_pal + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_pal: + move $fp, $sp + subu $sp, $sp, 188 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -48($fp) + lw $t1 -52($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -36($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 -124($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # - + lw $a0, -104($fp) + lw $a1, -108($fp) + sub $a0, $a0, $a1 + sw $a0, -100($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -76($fp) + lw $t1 -92($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -64($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -64($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # IF GOTO + lw $a0, -60($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -128($fp) + sw $a0, -56($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -164($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -164($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + lw $a2, -164($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 2 + sw $a0 12($a1) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -152($fp) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # - + lw $a0, -152($fp) + lw $a1, -156($fp) + sub $a0, $a0, $a1 + sw $a0, -148($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -176($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -140($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -140($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + lw $a2, -140($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -132($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -132($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + lw $a2, -132($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -136($fp) + sw $a0, -56($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -56($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -184($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 88 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # - + li $a0 0 + lw $a1, 0($fp) + sub $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -32($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -32($fp) + +_cil_label_LABEL_7: + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 88 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/palindrome.s b/tests/codegen/palindrome.s new file mode 100644 index 00000000..195901ab --- /dev/null +++ b/tests/codegen/palindrome.s @@ -0,0 +1,2354 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "enter a string\n" + data_2: .align 2 + .asciiz "that was not a palindrome\n" + data_3: .align 2 + .asciiz "that was a palindrome\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_pal + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_pal: + move $fp, $sp + subu $sp, $sp, 188 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -20($fp) + lw $t1 -24($fp) + beq $t0 $zero _eq_false_1_ + beq $t1 $zero _eq_false_1_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_1 + li $a2 5 + beq $a0 $a2 _eq_int_bool_1 + li $a2 6 + bne $a0 $a2 _not_basic_type_1_ +_eq_str_1_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_1_ + beq $t3 $0 _eq_true_1_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_1_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_1_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_1_ + b _eq_true_1_ +_not_basic_type_1_: + bne $t0 $t1 _eq_false_1_ + b _eq_true_1_ +_eq_int_bool_1: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_1_ +_eq_true_1_: + li $a0 1 + sw $a0 -8($fp) + b end_equal_1_ +_eq_false_1_: + li $a0 0 + sw $a0 -8($fp) +end_equal_1_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -52($fp) + li $a0, 1 + sw $a0 12($a1) + + lw $t0 -48($fp) + lw $t1 -52($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -36($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -36($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + lw $a0 -36($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -32($fp) + + # IF GOTO + lw $a0, -32($fp) + bnez $a0, _cil_label_LABEL_2 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 0 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -96($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -96($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -96($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -116($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -116($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + lw $a2, -116($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -124($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -124($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 -124($fp) + lw $a0 12($a1) + sw $a0 -108($fp) + + # - + lw $a0, -104($fp) + lw $a1, -108($fp) + sub $a0, $a0, $a1 + sw $a0, -100($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -112($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -112($fp) + lw $a0 -100($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -112($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -88($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -88($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -92($fp) + lw $a2, -88($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + lw $t0 -76($fp) + lw $t1 -92($fp) + beq $t0 $zero _eq_false_3_ + beq $t1 $zero _eq_false_3_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_3 + li $a2 5 + beq $a0 $a2 _eq_int_bool_3 + li $a2 6 + bne $a0 $a2 _not_basic_type_3_ +_eq_str_3_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_3_ + beq $t3 $0 _eq_true_3_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_3_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_3_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_3_ + b _eq_true_3_ +_not_basic_type_3_: + bne $t0 $t1 _eq_false_3_ + b _eq_true_3_ +_eq_int_bool_3: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_3_ +_eq_true_3_: + li $a0 1 + sw $a0 -64($fp) + b end_equal_3_ +_eq_false_3_: + li $a0 0 + sw $a0 -64($fp) +end_equal_3_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -64($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -68($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # IF GOTO + lw $a0, -60($fp) + bnez $a0, _cil_label_LABEL_4 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -128($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -128($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -128($fp) + sw $a0, -56($fp) + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -164($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -164($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -168($fp) + lw $a2, -164($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -172($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -172($fp) + li $a0, 2 + sw $a0 12($a1) + + # GETATTR + lw $a1 -168($fp) + lw $a0 12($a1) + sw $a0 -152($fp) + + # GETATTR + lw $a1 -172($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # - + lw $a0, -152($fp) + lw $a1, -156($fp) + sub $a0, $a0, $a1 + sw $a0, -148($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -160($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -176($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -176($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -176($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 16($fp) + lw $a0 0($a1) + sw $a0 -140($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -140($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + lw $a2, -140($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -144($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -132($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -132($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -136($fp) + lw $a2, -132($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -136($fp) + sw $a0, -56($fp) + +_cil_label_LABEL_5: + # ASSIGN + lw $a0, -56($fp) + sw $a0, -28($fp) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_2: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -180($fp) + sw $a0, -28($fp) + +_cil_label_LABEL_3: + # ASSIGN + lw $a0, -28($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -184($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -184($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -184($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 188 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 88 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # - + li $a0 0 + lw $a1, 0($fp) + sub $a0, $a0, $a1 + sw $a0, -4($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 15 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + lw $a0 -28($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -24($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 16($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 -44($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_6 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + lw $a0 -68($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -64($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -56($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -56($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + lw $a2, -56($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -60($fp) + sw $a0, -32($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -80($fp) + lw $a0 -84($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -80($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -80($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -72($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -72($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -76($fp) + lw $a2, -72($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -76($fp) + sw $a0, -32($fp) + +_cil_label_LABEL_7: + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 88 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/primes.mips b/tests/codegen/primes.mips new file mode 100644 index 00000000..f0843852 --- /dev/null +++ b/tests/codegen/primes.mips @@ -0,0 +1,2493 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "2 is trivially prime.\n" + data_2: .align 2 + .asciiz " is prime.\n" + data_3: .align 2 + .asciiz "continue" + data_4: .align 2 + .asciiz "Abort called from class String\n" + data_5: .align 2 + .asciiz "halt" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 32 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 420 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 2 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -20($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -24($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 500 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -28($fp) + sw $a0 24($a1) + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_1 + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # + + lw $a0, -48($fp) + lw $a1, -52($fp) + add $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -56($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 2 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -68($fp) + sw $a0 20($a1) + +_cil_label_LABEL_3: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -124($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -128($fp) + + # GETATTR + lw $a1 -124($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -116($fp) + + # * + lw $a0, -112($fp) + lw $a1, -116($fp) + mul $a0, $a0, $a1 + sw $a0, -108($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -104($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # < + lw $a1, -92($fp) + lw $a2, -96($fp) + slt $a0, $a1, $a2 + sw $a0, -88($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_6 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -164($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -184($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -204($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -208($fp) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -192($fp) + + # GETATTR + lw $a1 -208($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # / + lw $a0, -192($fp) + lw $a1, -196($fp) + beqz $a1 _div_error_1_ + div $a0, $a0, $a1 + sw $a0, -188($fp) + b _div_end_1_ +_div_error_1_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_1_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -200($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -184($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # GETATTR + lw $a1 -200($fp) + lw $a0 12($a1) + sw $a0 -176($fp) + + # * + lw $a0, -172($fp) + lw $a1, -176($fp) + mul $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -164($fp) + lw $a0 12($a1) + sw $a0 -152($fp) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # - + lw $a0, -152($fp) + lw $a1, -156($fp) + sub $a0, $a0, $a1 + sw $a0, -148($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -160($fp) + lw $t1 -212($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -140($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -140($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -144($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # IF GOTO + lw $a0, -136($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -216($fp) + sw $a0, -132($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -220($fp) + sw $a0, -132($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -132($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_7: + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_4 + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -244($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -244($fp) + lw $a0 12($a1) + sw $a0 -232($fp) + + # GETATTR + lw $a1 -248($fp) + lw $a0 12($a1) + sw $a0 -236($fp) + + # + + lw $a0, -232($fp) + lw $a1, -236($fp) + add $a0, $a0, $a1 + sw $a0, -228($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -228($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -240($fp) + sw $a0 20($a1) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_5: + # ALLOCATE + la $v0 type_void + sw $v0 -72($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -276($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -296($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -300($fp) + + # GETATTR + lw $a1 -296($fp) + lw $a0 12($a1) + sw $a0 -284($fp) + + # GETATTR + lw $a1 -300($fp) + lw $a0 12($a1) + sw $a0 -288($fp) + + # * + lw $a0, -284($fp) + lw $a1, -288($fp) + mul $a0, $a0, $a1 + sw $a0, -280($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + lw $a0 -280($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -276($fp) + lw $a0 12($a1) + sw $a0 -264($fp) + + # GETATTR + lw $a1 -292($fp) + lw $a0 12($a1) + sw $a0 -268($fp) + + # < + lw $a1, -264($fp) + lw $a2, -268($fp) + slt $a0, $a1, $a2 + sw $a0, -260($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -272($fp) + lw $a0 12($a1) + sw $a0 -256($fp) + + # IF GOTO + lw $a0, -256($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -252($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -308($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -308($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -320($fp) + + # PUSHPARAM + lw $a0, -320($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -312($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -312($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + lw $a2, -312($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -332($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -332($fp) + lw $a0 -336($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -332($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -332($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -324($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -324($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + lw $a2, -324($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -328($fp) + sw $a0, -252($fp) + +_cil_label_LABEL_11: + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -364($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -368($fp) + + # GETATTR + lw $a1 -364($fp) + lw $a0 12($a1) + sw $a0 -352($fp) + + # GETATTR + lw $a1 -368($fp) + lw $a0 12($a1) + sw $a0 -356($fp) + + # <= + lw $a1, -352($fp) + lw $a2, -356($fp) + sle $a0, $a1, $a2 + sw $a0, -348($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -360($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -360($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -360($fp) + lw $a0 12($a1) + sw $a0 -344($fp) + + # IF GOTO + lw $a0, -344($fp) + bnez $a0, _cil_label_LABEL_12 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + li $a0, 8 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -372($fp) + lw $a0 -376($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -372($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -372($fp) + sw $a0, -340($fp) + + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_12: + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -380($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -380($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -384($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -400($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -400($fp) + li $a0, 31 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -396($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -396($fp) + lw $a0 -400($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -396($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -396($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -380($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -380($fp) + lw $a0 0($a1) + sw $a0 -388($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -388($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -392($fp) + lw $a2, -388($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -408($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -408($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -404($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -404($fp) + lw $a0 -408($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -404($fp) + la $a0, data_5 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -404($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -404($fp) + lw $a0 0($a1) + sw $a0 -412($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -412($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -416($fp) + lw $a2, -412($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -416($fp) + sw $a0, -340($fp) + +_cil_label_LABEL_13: + # GOTO + j _cil_label_LABEL_0 + +_cil_label_LABEL_2: + # ALLOCATE + la $v0 type_void + sw $v0 -32($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -32($fp) + sw $a0 28($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 420 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/primes.s b/tests/codegen/primes.s new file mode 100644 index 00000000..5621ec0b --- /dev/null +++ b/tests/codegen/primes.s @@ -0,0 +1,2365 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "2 is trivially prime.\n" + data_2: .align 2 + .asciiz " is prime.\n" + data_3: .align 2 + .asciiz "continue" + data_4: .align 2 + .asciiz "halt" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 32 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 396 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 22 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + li $a0, 2 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -16($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -20($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -24($fp) + sw $a0 20($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -28($fp) + li $a0, 500 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -28($fp) + sw $a0 24($a1) + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -40($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -40($fp) + lw $a0 12($a1) + sw $a0 -36($fp) + + # IF GOTO + lw $a0, -36($fp) + bnez $a0, _cil_label_LABEL_1 + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_1: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -60($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -64($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -60($fp) + lw $a0 12($a1) + sw $a0 -48($fp) + + # GETATTR + lw $a1 -64($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # + + lw $a0, -48($fp) + lw $a1, -52($fp) + add $a0, $a0, $a1 + sw $a0, -44($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -56($fp) + lw $a0 -44($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -56($fp) + sw $a0 16($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 2 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -68($fp) + sw $a0 20($a1) + +_cil_label_LABEL_3: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -104($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -124($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -128($fp) + + # GETATTR + lw $a1 -124($fp) + lw $a0 12($a1) + sw $a0 -112($fp) + + # GETATTR + lw $a1 -128($fp) + lw $a0 12($a1) + sw $a0 -116($fp) + + # * + lw $a0, -112($fp) + lw $a1, -116($fp) + mul $a0, $a0, $a1 + sw $a0, -108($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -120($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -120($fp) + lw $a0 -108($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -104($fp) + lw $a0 12($a1) + sw $a0 -92($fp) + + # GETATTR + lw $a1 -120($fp) + lw $a0 12($a1) + sw $a0 -96($fp) + + # < + lw $a1, -92($fp) + lw $a2, -96($fp) + slt $a0, $a1, $a2 + sw $a0, -88($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -100($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -100($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -100($fp) + lw $a0 12($a1) + sw $a0 -84($fp) + + # IF GOTO + lw $a0, -84($fp) + bnez $a0, _cil_label_LABEL_6 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -164($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -184($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -204($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -208($fp) + + # GETATTR + lw $a1 -204($fp) + lw $a0 12($a1) + sw $a0 -192($fp) + + # GETATTR + lw $a1 -208($fp) + lw $a0 12($a1) + sw $a0 -196($fp) + + # / + lw $a0, -192($fp) + lw $a1, -196($fp) + beqz $a1 _div_error_1_ + div $a0, $a0, $a1 + sw $a0, -188($fp) + b _div_end_1_ +_div_error_1_: + la $a0 _div_zero_msg + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_div_end_1_: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -200($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -200($fp) + lw $a0 -188($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -184($fp) + lw $a0 12($a1) + sw $a0 -172($fp) + + # GETATTR + lw $a1 -200($fp) + lw $a0 12($a1) + sw $a0 -176($fp) + + # * + lw $a0, -172($fp) + lw $a1, -176($fp) + mul $a0, $a0, $a1 + sw $a0, -168($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -180($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -180($fp) + lw $a0 -168($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -164($fp) + lw $a0 12($a1) + sw $a0 -152($fp) + + # GETATTR + lw $a1 -180($fp) + lw $a0 12($a1) + sw $a0 -156($fp) + + # - + lw $a0, -152($fp) + lw $a1, -156($fp) + sub $a0, $a0, $a1 + sw $a0, -148($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -160($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -160($fp) + lw $a0 -148($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -212($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -212($fp) + li $a0, 0 + sw $a0 12($a1) + + lw $t0 -160($fp) + lw $t1 -212($fp) + beq $t0 $zero _eq_false_2_ + beq $t1 $zero _eq_false_2_ + lw $a0 0($t0) + lw $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + li $a2 4 + beq $a0 $a2 _eq_int_bool_2 + li $a2 5 + beq $a0 $a2 _eq_int_bool_2 + li $a2 6 + bne $a0 $a2 _not_basic_type_2_ +_eq_str_2_: + lw $t3 12($t0) + lw $t3 12($t3) + lw $t4, 12($t1) + lw $t4, 12($t4) + bne $t3 $t4 _eq_false_2_ + beq $t3 $0 _eq_true_2_ + addu $t0 $t0 16 + lw $t0 0($t0) + addu $t1 $t1 16 + lw $t1 0($t1) + move $t2 $t3 +_verify_ascii_sequences_2_: + lb $a0 0($t0) + lb $a1 0($t1) + bne $a0 $a1 _eq_false_2_ + addu $t0 $t0 1 + addu $t1 $t1 1 + addiu $t2 $t2 -1 + bnez $t2 _verify_ascii_sequences_2_ + b _eq_true_2_ +_not_basic_type_2_: + bne $t0 $t1 _eq_false_2_ + b _eq_true_2_ +_eq_int_bool_2: + lw $a3 12($t0) + lw $t4 12($t1) + bne $a3 $t4 _eq_false_2_ +_eq_true_2_: + li $a0 1 + sw $a0 -140($fp) + b end_equal_2_ +_eq_false_2_: + li $a0 0 + sw $a0 -140($fp) +end_equal_2_: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -144($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -144($fp) + lw $a0 -140($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -144($fp) + lw $a0 12($a1) + sw $a0 -136($fp) + + # IF GOTO + lw $a0, -136($fp) + bnez $a0, _cil_label_LABEL_8 + + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -216($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -216($fp) + li $a0, 1 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -216($fp) + sw $a0, -132($fp) + + # GOTO + j _cil_label_LABEL_9 + +_cil_label_LABEL_8: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -220($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -220($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -220($fp) + sw $a0, -132($fp) + +_cil_label_LABEL_9: + # ASSIGN + lw $a0, -132($fp) + sw $a0, -80($fp) + + # GOTO + j _cil_label_LABEL_7 + +_cil_label_LABEL_6: + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -224($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -224($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -224($fp) + sw $a0, -80($fp) + +_cil_label_LABEL_7: + # GETATTR + lw $a1 -80($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # IF GOTO + lw $a0, -76($fp) + bnez $a0, _cil_label_LABEL_4 + + # GOTO + j _cil_label_LABEL_5 + +_cil_label_LABEL_4: + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -244($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -248($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -248($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -244($fp) + lw $a0 12($a1) + sw $a0 -232($fp) + + # GETATTR + lw $a1 -248($fp) + lw $a0 12($a1) + sw $a0 -236($fp) + + # + + lw $a0, -232($fp) + lw $a1, -236($fp) + add $a0, $a0, $a1 + sw $a0, -228($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -240($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -240($fp) + lw $a0 -228($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 -240($fp) + sw $a0 20($a1) + + # GOTO + j _cil_label_LABEL_3 + +_cil_label_LABEL_5: + # ALLOCATE + la $v0 type_void + sw $v0 -72($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -276($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -296($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 20($a1) + sw $a0 -300($fp) + + # GETATTR + lw $a1 -296($fp) + lw $a0 12($a1) + sw $a0 -284($fp) + + # GETATTR + lw $a1 -300($fp) + lw $a0 12($a1) + sw $a0 -288($fp) + + # * + lw $a0, -284($fp) + lw $a1, -288($fp) + mul $a0, $a0, $a1 + sw $a0, -280($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -292($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -292($fp) + lw $a0 -280($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -276($fp) + lw $a0 12($a1) + sw $a0 -264($fp) + + # GETATTR + lw $a1 -292($fp) + lw $a0 12($a1) + sw $a0 -268($fp) + + # < + lw $a1, -264($fp) + lw $a2, -268($fp) + slt $a0, $a1, $a2 + sw $a0, -260($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -272($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -272($fp) + lw $a0 -260($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -272($fp) + lw $a0 12($a1) + sw $a0 -256($fp) + + # IF GOTO + lw $a0, -256($fp) + bnez $a0, _cil_label_LABEL_10 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -304($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -304($fp) + li $a0, 0 + sw $a0 12($a1) + + # ASSIGN + lw $a0, -304($fp) + sw $a0, -252($fp) + + # GOTO + j _cil_label_LABEL_11 + +_cil_label_LABEL_10: + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -308($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -308($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -320($fp) + + # PUSHPARAM + lw $a0, -320($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -312($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -312($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -316($fp) + lw $a2, -312($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -336($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -336($fp) + li $a0, 11 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -332($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -332($fp) + lw $a0 -336($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -332($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -332($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -324($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -324($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -328($fp) + lw $a2, -324($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -328($fp) + sw $a0, -252($fp) + +_cil_label_LABEL_11: + # GETATTR + lw $a1 12($fp) + lw $a0 24($a1) + sw $a0 -364($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -368($fp) + + # GETATTR + lw $a1 -364($fp) + lw $a0 12($a1) + sw $a0 -352($fp) + + # GETATTR + lw $a1 -368($fp) + lw $a0 12($a1) + sw $a0 -356($fp) + + # <= + lw $a1, -352($fp) + lw $a2, -356($fp) + sle $a0, $a1, $a2 + sw $a0, -348($fp) + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -360($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -360($fp) + lw $a0 -348($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -360($fp) + lw $a0 12($a1) + sw $a0 -344($fp) + + # IF GOTO + lw $a0, -344($fp) + bnez $a0, _cil_label_LABEL_12 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -376($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -376($fp) + li $a0, 8 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -372($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -372($fp) + lw $a0 -376($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -372($fp) + la $a0, data_3 + sw $a0 16($a1) + + # ASSIGN + lw $a0, -372($fp) + sw $a0, -340($fp) + + # GOTO + j _cil_label_LABEL_13 + +_cil_label_LABEL_12: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -384($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -384($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -380($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -380($fp) + lw $a0 -384($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -380($fp) + la $a0, data_4 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -380($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -380($fp) + lw $a0 0($a1) + sw $a0 -388($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -388($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -392($fp) + lw $a2, -388($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -392($fp) + sw $a0, -340($fp) + +_cil_label_LABEL_13: + # GOTO + j _cil_label_LABEL_0 + +_cil_label_LABEL_2: + # ALLOCATE + la $v0 type_void + sw $v0 -32($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -32($fp) + sw $a0 28($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 396 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/print-cool.mips b/tests/codegen/print-cool.mips new file mode 100644 index 00000000..c35dd01e --- /dev/null +++ b/tests/codegen/print-cool.mips @@ -0,0 +1,1456 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 8($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 8($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 4 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function__isvoid + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 8($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 3 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -4($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/print-cool.s b/tests/codegen/print-cool.s new file mode 100644 index 00000000..c9a12cb9 --- /dev/null +++ b/tests/codegen/print-cool.s @@ -0,0 +1,1452 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 92 + # ALLOCATE + lw $t0 8($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 8($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -36($fp) + li $a0, 4 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function__isvoid + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -48($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -48($fp) + lw $a0 0($a1) + sw $a0 -52($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -52($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 8($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -56($fp) + lw $a2, -52($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + li $a0, 3 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -68($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # PUSHPARAM + lw $a0, -72($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -56($fp) + lw $a0 0($a1) + sw $a0 -60($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -60($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + lw $a2, -60($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -64($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -4($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -4($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -88($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -88($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -84($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -84($fp) + lw $a0 -88($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -84($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -84($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -76($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -76($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -80($fp) + lw $a2, -76($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -80($fp) + addiu $sp, $sp, 92 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/codegen/sort-list.mips b/tests/codegen/sort-list.mips new file mode 100644 index 00000000..4a7f0f23 --- /dev/null +++ b/tests/codegen/sort-list.mips @@ -0,0 +1,3876 @@ +#Compiled by DiazRock COOL compiler +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "Abort called from class List\n" + data_2: .align 2 + .asciiz "\n" + data_3: .align 2 + .asciiz "How many numbers to sort? " + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_List: .align 2 + .asciiz "List" + classname_Cons: .align 2 + .asciiz "Cons" + classname_Nil: .align 2 + .asciiz "Nil" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + li $v0 10 + syscall + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 40 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_List + sw $t1 12($s1) + la $t1 classname_Cons + sw $t1 16($s1) + la $t1 classname_Nil + sw $t1 20($s1) + la $t1 classname_Main + sw $t1 24($s1) + la $t1 classname_Int + sw $t1 28($s1) + la $t1 classname_Bool + sw $t1 32($s1) + la $t1 classname_String + sw $t1 36($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 80 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type List + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Nil + li $a0 12 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 72($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type List + li $a0 64 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_List_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_List_car + sw $t1 36($v0) + la $t1 function_List_cdr + sw $t1 40($v0) + la $t1 function_List_rev + sw $t1 44($v0) + la $t1 function_List_sort + sw $t1 48($v0) + la $t1 function_List_insert + sw $t1 52($v0) + la $t1 function_List_rcons + sw $t1 56($v0) + la $t1 function_List_print_list + sw $t1 60($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 68 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Cons_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_Cons_car + sw $t1 36($v0) + la $t1 function_Cons_cdr + sw $t1 40($v0) + la $t1 function_Cons_rev + sw $t1 44($v0) + la $t1 function_Cons_sort + sw $t1 48($v0) + la $t1 function_Cons_insert + sw $t1 52($v0) + la $t1 function_Cons_rcons + sw $t1 56($v0) + la $t1 function_Cons_print_list + sw $t1 60($v0) + la $t1 function_Cons_init + sw $t1 64($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Nil + li $a0 64 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Nil_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_List_car + sw $t1 36($v0) + la $t1 function_List_cdr + sw $t1 40($v0) + la $t1 function_Nil_rev + sw $t1 44($v0) + la $t1 function_Nil_sort + sw $t1 48($v0) + la $t1 function_Nil_insert + sw $t1 52($v0) + la $t1 function_Nil_rcons + sw $t1 56($v0) + la $t1 function_Nil_print_list + sw $t1 60($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_iota + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 40 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List_isNil: + move $fp, $sp + subu $sp, $sp, 36 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 36 + jr $ra + +function_List_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_List_car: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 40 + jr $ra + +function_List_cdr: + move $fp, $sp + subu $sp, $sp, 40 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -32($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -32($fp) + addiu $sp, $sp, 40 + jr $ra + +function_List_rev: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_sort: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_insert: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_rcons: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_print_list: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 16($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + li $a0, 29 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -16($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -16($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -28($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Cons_car: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_cdr: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_rev: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -16($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Cons_sort: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -16($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Cons_insert: + move $fp, $sp + subu $sp, $sp, 76 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -40($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -60($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -72($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 76 + jr $ra + +function_Cons_rcons: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Cons_print_list: + move $fp, $sp + subu $sp, $sp, 40 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 60($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_Nil__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Nil_rev: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_sort: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_insert: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Nil_rcons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Nil_print_list: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_iota: + move $fp, $sp + subu $sp, $sp, 80 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Nil__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_2: + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # < + lw $a1, -24($fp) + lw $a2, -28($fp) + slt $a0, $a1, $a2 + sw $a0, -20($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # IF GOTO + lw $a0, -16($fp) + bnez $a0, _cil_label_LABEL_3 + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 64($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -68($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_4: + # ALLOCATE + la $v0 type_void + sw $v0 -12($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # RETURN + lw $v0, -76($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 56 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_3 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 60($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -52($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + + +##################################### + diff --git a/tests/codegen/sort-list.s b/tests/codegen/sort-list.s new file mode 100644 index 00000000..c532030a --- /dev/null +++ b/tests/codegen/sort-list.s @@ -0,0 +1,3495 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "\n" + data_2: .align 2 + .asciiz "How many numbers to sort? " + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_List: .align 2 + .asciiz "List" + classname_Cons: .align 2 + .asciiz "Cons" + classname_Nil: .align 2 + .asciiz "Nil" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 40 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_List + sw $t1 12($s1) + la $t1 classname_Cons + sw $t1 16($s1) + la $t1 classname_Nil + sw $t1 20($s1) + la $t1 classname_Main + sw $t1 24($s1) + la $t1 classname_Int + sw $t1 28($s1) + la $t1 classname_Bool + sw $t1 32($s1) + la $t1 classname_String + sw $t1 36($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 80 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type List + li $a0 12 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Cons + li $a0 20 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Nil + li $a0 12 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 8 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 64($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 9 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 72($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type List + li $a0 64 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_List_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_List_car + sw $t1 36($v0) + la $t1 function_List_cdr + sw $t1 40($v0) + la $t1 function_List_rev + sw $t1 44($v0) + la $t1 function_List_sort + sw $t1 48($v0) + la $t1 function_List_insert + sw $t1 52($v0) + la $t1 function_List_rcons + sw $t1 56($v0) + la $t1 function_List_print_list + sw $t1 60($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Cons + li $a0 100 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_List_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_List_car + sw $t1 36($v0) + la $t1 function_List_cdr + sw $t1 40($v0) + la $t1 function_List_rev + sw $t1 44($v0) + la $t1 function_List_sort + sw $t1 48($v0) + la $t1 function_List_insert + sw $t1 52($v0) + la $t1 function_List_rcons + sw $t1 56($v0) + la $t1 function_List_print_list + sw $t1 60($v0) + la $t1 function_Cons_isNil + sw $t1 64($v0) + la $t1 function_Cons_init + sw $t1 68($v0) + la $t1 function_Cons_car + sw $t1 72($v0) + la $t1 function_Cons_cdr + sw $t1 76($v0) + la $t1 function_Cons_rev + sw $t1 80($v0) + la $t1 function_Cons_sort + sw $t1 84($v0) + la $t1 function_Cons_insert + sw $t1 88($v0) + la $t1 function_Cons_rcons + sw $t1 92($v0) + la $t1 function_Cons_print_list + sw $t1 96($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Nil + li $a0 88 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_List_isNil + sw $t1 28($v0) + la $t1 function_List_cons + sw $t1 32($v0) + la $t1 function_List_car + sw $t1 36($v0) + la $t1 function_List_cdr + sw $t1 40($v0) + la $t1 function_List_rev + sw $t1 44($v0) + la $t1 function_List_sort + sw $t1 48($v0) + la $t1 function_List_insert + sw $t1 52($v0) + la $t1 function_List_rcons + sw $t1 56($v0) + la $t1 function_List_print_list + sw $t1 60($v0) + la $t1 function_Nil_isNil + sw $t1 64($v0) + la $t1 function_Nil_rev + sw $t1 68($v0) + la $t1 function_Nil_sort + sw $t1 72($v0) + la $t1 function_Nil_insert + sw $t1 76($v0) + la $t1 function_Nil_rcons + sw $t1 80($v0) + la $t1 function_Nil_print_list + sw $t1 84($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type Main + li $a0 36 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_iota + sw $t1 28($v0) + la $t1 function_Main_main + sw $t1 32($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 64($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 72($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 40 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 8 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 9 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 3 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_List_isNil: + move $fp, $sp + subu $sp, $sp, 12 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 12 + jr $ra + +function_List_cons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_List_car: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_List_cdr: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -8($fp) + addiu $sp, $sp, 16 + jr $ra + +function_List_rev: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_sort: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_insert: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_rcons: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 40($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_List_print_list: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 0($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons__init: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Int__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + la $v0 type_void + sw $v0 -4($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Cons_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_init: + move $fp, $sp + subu $sp, $sp, 0 + # SETATTR + lw $a1 12($fp) + lw $a0 16($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 20($fp) + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Cons_car: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_cdr: + move $fp, $sp + subu $sp, $sp, 4 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Cons_rev: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -16($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Cons_sort: + move $fp, $sp + subu $sp, $sp, 24 + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 0($fp) + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -4($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -4($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + lw $a2, -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -20($fp) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -8($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -16($fp) + addiu $sp, $sp, 24 + jr $ra + +function_Cons_insert: + move $fp, $sp + subu $sp, $sp, 76 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -12($fp) + + # GETATTR + lw $a1 -24($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # < + lw $a1, -12($fp) + lw $a2, -16($fp) + slt $a0, $a1, $a2 + sw $a0, -8($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -8($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -20($fp) + lw $a0 12($a1) + sw $a0 -4($fp) + + # IF GOTO + lw $a0, -4($fp) + bnez $a0, _cil_label_LABEL_0 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -44($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 52($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -56($fp) + + # PUSHPARAM + lw $a0, -56($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -36($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -36($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + lw $a2, -36($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -40($fp) + sw $a0, 0($fp) + + # GOTO + j _cil_label_LABEL_1 + +_cil_label_LABEL_0: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -60($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -64($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -60($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -60($fp) + lw $a0 0($a1) + sw $a0 -68($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -68($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + lw $a2, -68($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ASSIGN + lw $a0, -72($fp) + sw $a0, 0($fp) + +_cil_label_LABEL_1: + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 76 + jr $ra + +function_Cons_rcons: + move $fp, $sp + subu $sp, $sp, 32 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -16($fp) + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -16($fp) + lw $a0 0($a1) + sw $a0 -20($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -20($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 56($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + lw $a2, -20($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -24($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 32 + jr $ra + +function_Cons_print_list: + move $fp, $sp + subu $sp, $sp, 40 + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -8($fp) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 20($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -24($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -24($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -20($fp) + lw $a0 -24($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -20($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -12($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -12($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -16($fp) + lw $a2, -12($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 16($a1) + sw $a0 -28($fp) + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -28($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 60($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -36($fp) + addiu $sp, $sp, 40 + jr $ra + +function_Nil__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_List__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_isNil: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Nil_rev: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_sort: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Nil_insert: + move $fp, $sp + subu $sp, $sp, 8 + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 80($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 8 + jr $ra + +function_Nil_rcons: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 16($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 0($fp) + lw $a0 0($a1) + sw $a0 -8($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -8($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + lw $a2, -8($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Nil_print_list: + move $fp, $sp + subu $sp, $sp, 4 + # ALLOCATE + lw $t0 64($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 1 + sw $a0 12($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + la $v0 type_void + sw $v0 0($fp) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Main_iota: + move $fp, $sp + subu $sp, $sp, 80 + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, 0($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Nil__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + li $a0, 0 + sw $a0 12($a1) + +_cil_label_LABEL_2: + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -24($fp) + + # GETATTR + lw $a1 16($fp) + lw $a0 12($a1) + sw $a0 -28($fp) + + # < + lw $a1, -24($fp) + lw $a2, -28($fp) + slt $a0, $a1, $a2 + sw $a0, -20($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -32($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -32($fp) + lw $a0 -20($fp) + sw $a0 12($a1) + + # GETATTR + lw $a1 -32($fp) + lw $a0 12($a1) + sw $a0 -16($fp) + + # IF GOTO + lw $a0, -16($fp) + bnez $a0, _cil_label_LABEL_3 + + # GOTO + j _cil_label_LABEL_4 + +_cil_label_LABEL_3: + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + + addiu $sp, $sp, 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Cons__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -52($fp) + + # PUSHPARAM + lw $a0, -52($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -44($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -44($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 68($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -48($fp) + lw $a2, -44($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -48($fp) + sw $a0 12($a1) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -72($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -72($fp) + li $a0, 1 + sw $a0 12($a1) + + # GETATTR + lw $a1 -8($fp) + lw $a0 12($a1) + sw $a0 -60($fp) + + # GETATTR + lw $a1 -72($fp) + lw $a0 12($a1) + sw $a0 -64($fp) + + # + + lw $a0, -60($fp) + lw $a1, -64($fp) + add $a0, $a0, $a1 + sw $a0, -56($fp) + + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -68($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -68($fp) + lw $a0 -56($fp) + sw $a0 12($a1) + + # ASSIGN + lw $a0, -68($fp) + sw $a0, -8($fp) + + # GOTO + j _cil_label_LABEL_2 + +_cil_label_LABEL_4: + # ALLOCATE + la $v0 type_void + sw $v0 -12($fp) + + # GETATTR + lw $a1 12($fp) + lw $a0 12($a1) + sw $a0 -76($fp) + + # RETURN + lw $v0, -76($fp) + addiu $sp, $sp, 80 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 56 + # ALLOCATE + lw $t0 56($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 26 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 72($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -24($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -24($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 12($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -28($fp) + lw $a2, -24($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -28($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 -16($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -16($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 28($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -20($fp) + lw $a2, -16($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -20($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -20($fp) + lw $a0 0($a1) + sw $a0 -32($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -32($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 44($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -36($fp) + lw $a2, -32($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -36($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -36($fp) + lw $a0 0($a1) + sw $a0 -40($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -40($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 48($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -44($fp) + lw $a2, -40($fp) + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, -44($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 -44($fp) + lw $a0 0($a1) + sw $a0 -48($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, -48($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 60($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -52($fp) + lw $a2, -48($fp) + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -52($fp) + addiu $sp, $sp, 56 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/semantic/inheritance2.mips b/tests/semantic/inheritance2.mips new file mode 100644 index 00000000..95ec1e08 --- /dev/null +++ b/tests/semantic/inheritance2.mips @@ -0,0 +1,1323 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "bye!" + data_2: .align 2 + .asciiz "hi!" + data_3: .align 2 + .asciiz "3" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + classname_Alo: .align 2 + .asciiz "Alo" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 32 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + la $t1 classname_Alo + sw $t1 28($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 64 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + # Type Alo + li $a0 16 + li $v0 9 + syscall + li $a0 7 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 56($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + # Type Alo + li $a0 16 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_Alo_x + sw $t1 12($v0) + lw $t0 56($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 32 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 7 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Alo__init: + move $fp, $sp + subu $sp, $sp, 4 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + li $a0, 3 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + lw $a0 0($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 4 + jr $ra + +function_Alo_x: + move $fp, $sp + subu $sp, $sp, 8 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -4($fp) + li $a0, 1 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 0($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 0($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 0($fp) + la $a0, data_3 + sw $a0 16($a1) + + # RETURN + lw $v0, 0($fp) + addiu $sp, $sp, 8 + jr $ra + + +##################################### + diff --git a/tests/semantic/inheritance3.mips b/tests/semantic/inheritance3.mips new file mode 100644 index 00000000..0342250c --- /dev/null +++ b/tests/semantic/inheritance3.mips @@ -0,0 +1,1177 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "bye!" + data_2: .align 2 + .asciiz "hi!" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/semantic/inheritance4.mips b/tests/semantic/inheritance4.mips new file mode 100644 index 00000000..0342250c --- /dev/null +++ b/tests/semantic/inheritance4.mips @@ -0,0 +1,1177 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "bye!" + data_2: .align 2 + .asciiz "hi!" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### + diff --git a/tests/semantic/inheritance5.mips b/tests/semantic/inheritance5.mips new file mode 100644 index 00000000..0342250c --- /dev/null +++ b/tests/semantic/inheritance5.mips @@ -0,0 +1,1177 @@ +.data + str_buffer: .space 1024 + + _index_negative_msg: .align 2 + .asciiz "Index to substr is negative\n" + _index_out_msg: .align 2 + .asciiz "Index out range exception\n" + _abort_msg: .align 2 + .asciiz "Execution aborted\n" + _div_zero_msg: .align 2 + .asciiz "Division by zero exception\n" + + data_0: .align 2 + .asciiz "" + data_1: .align 2 + .asciiz "bye!" + data_2: .align 2 + .asciiz "hi!" + + classname_void: .align 2 + .asciiz "void" + classname_Object: .align 2 + .asciiz "Object" + classname_IO: .align 2 + .asciiz "IO" + classname_Main: .align 2 + .asciiz "Main" + classname_Int: .align 2 + .asciiz "Int" + classname_Bool: .align 2 + .asciiz "Bool" + classname_String: .align 2 + .asciiz "String" + type_void: .align 2 + .asciiz "" + +.text +main: + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_name_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_allocate_prototypes_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_prototypes + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_dispatch_tables + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_build_class_parents_table + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + # ALLOCATE + lw $t0 24($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + sw $v0 0($sp) + addiu $sp $sp -4 + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Main_main + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp $sp 4 + li $v0 10 + syscall + +########## STATIC FUNCTIONS ########## + +function___conforms: + move $fp, $sp + lw $t0 12($fp) + lw $t1 16($fp) + beq $t1 1 _conforms_ret_true_ +_conforms_loop_: + beq $t0 $t1 _conforms_ret_true_ + beq $t0 1 _conforms_ret_false_ + mul $t0 $t0 4 + addu $t0 $t0 $s2 + lw $t0 0($t0) + j _conforms_loop_ +_conforms_ret_true_: + li $v0 1 + j _conforms_ret_ +_conforms_ret_false_: + li $v0 0 + _conforms_ret_: + jr $ra + +function__isvoid: + move $fp, $sp + # ALLOCATE + lw $t0 40($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $t0 12($fp) + la $t1 type_void + beq $t0 $t1 _is_void_true_ + sw $0 12($v0) + j _is_void_end_ +_is_void_true_: + li $t0 1 + sw $t0 12($v0) +_is_void_end_: + jr $ra + +function_Object_abort: + move $fp, $sp + jr $ra + +function_Object_copy: + move $fp, $sp + lw $t0 12($fp) + lw $a0 4($t0) + move $t4 $a0 + li $v0 9 + syscall + move $t2 $v0 + li $t3 0 +_objcopy_loop: + lw $t1 0($t0) + sw $t1 0($v0) + addiu $t0 $t0 4 + addiu $v0 $v0 4 + addiu $t3 $t3 4 + ble $t4 $t3 _objcopy_loop +_objcopy_div_end_: + move $v0 $t2 + jr $ra + +function_Object_type_name: + move $fp, $sp + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + lw $a1 12($fp) + lw $a1 0($a1) + mul $a1 $a1 4 + addu $a1 $a1 $s1 + lw $a1 0($a1) + move $a2 $0 + move $t2 $a1 +_str_len_clsname_: + lb $a0 0($t2) + beq $a0 $0 _end_clsname_len_ + addiu $a2 $a2 1 + addiu $t2 $t2 1 + j _str_len_clsname_ +_end_clsname_len_: + sw $a2, 12($v0) + sw $v0, 12($v1) + sw $a1, 16($v1) + move $v0 $v1 + jr $ra + +function_String_length: + move $fp, $sp + lw $a0 12($fp) + lw $v0 12($a0) + jr $ra + +function_String_concat: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t3 $v0 + lw $a1 12($fp) + lw $a2 16($fp) + lw $t1 12($a1) + lw $t1 12($t1) + lw $t2 12($a2) + lw $t2 12($t2) + addu $t0 $t2 $t1 + sw $t0 12($v1) + lw $a1 16($a1) + lw $a2 16($a2) + addiu $t0 $t0 1 + move $a0 $t0 + li $v0 9 + syscall + move $t5 $v0 + move $t4 $a1 + addu $a1 $a1 $t1 +_strcat_copy_: + beq $t4 $a1 _end_strcat_copy_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_ +_end_strcat_copy_: + move $t4 $a2 + addu $a2 $a2 $t2 +_strcat_copy_snd_: + beq $t4 $a2 _end_strcat_copy_snd_ + lb $a0 0($t4) + sb $a0 0($t5) + addiu $t5 $t5 1 + addiu $t4 $t4 1 + j _strcat_copy_snd_ +_end_strcat_copy_snd_: + sb $0 0($t5) + sw $v1 12($t3) + sw $v0 16($t3) + move $v0 $t3 + jr $ra + +function_String_substr: + move $fp, $sp + lw $t5 12($fp) + lw $a1 16($fp) + lw $a1 12($a1) + lw $a2 20($fp) + lw $a2 12($a2) + blt $a1 $0 _index_negative + blt $a2 $0 _index_negative + add $a2 $a1 $a2 + lw $a3 12($t5) + lw $a3 12($a3) + bgt $a2 $a3 _index_out + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + move $t7 $a2 + subu $t7 $t7 $a1 + sw $t7 12($t0) + move $a0 $a2 + li $v0 9 + syscall + sw $t0 12($v1) + sw $v0 16($v1) + move $t1 $v0 + lw $t5 16($t5) + move $t4 $t5 + addu $t4 $t4 $a1 + addu $t5 $t5 $a2 +_substr_copy_: + bge $t4 $t5 _end_substr_copy_ + lb $a0 0($t4) + sb $a0 0($t1) + addiu $t1 $t1 1 + addiu $t4 $t4 1 + j _substr_copy_ +_index_negative: + la $a0 _index_negative_msg + b _subst_abort +_index_out: + la $a0 _index_out_msg + b _subst_abort +_subst_abort: + li $v0 4 + syscall + la $a0 _abort_msg + li $v0 4 + syscall + li $v0 10 + syscall +_end_substr_copy_: + move $v0 $v1 + jr $ra + +function_IO_in_int: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $t0 $v0 + li $v0 5 + syscall + sw $v0 12($t0) + move $v0 $t0 + jr $ra + +function_IO_in_string: + move $fp, $sp + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + move $v1 $v0 + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + addiu $sp, $sp, 4 + + sw $v1 12($v0) + move $t5 $v0 + la $a0 str_buffer + li $a1 1025 + li $v0 8 + syscall + move $a0 $0 + la $t2 str_buffer +_in_string_str_len_: + lb $t0 0($t2) + beq $t0 $0 _end_in_string_str_len_ + beq $t0 10 _end_in_string_str_len_ + addiu $a0 $a0 1 + addiu $t2 $t2 1 + j _in_string_str_len_ +_end_in_string_str_len_: + sw $a0 12($v1) + li $v0 9 + syscall + la $t4 str_buffer + move $t1 $v0 +_in_str_copy_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_copy_ + beq $t0 10 _end_in_str_copy_ + sb $t0 0($t1) + addiu $t4 $t4 1 + addiu $t1 $t1 1 + j _in_str_copy_ +_end_in_str_copy_: + sw $v0 16($t5) + la $t4 str_buffer +_in_str_clean_: + lb $t0 0($t4) + beq $t0 $0 _end_in_str_clean_ + sb $0 0($t4) + addiu $t4 $t4 1 + j _in_str_clean_ +_end_in_str_clean_: + move $v0 $t5 + jr $ra + +function_IO_out_int: + move $fp, $sp + lw $a0 16($fp) + lw $a0 12($a0) + li $v0 1 + syscall + lw $v0 12($fp) + jr $ra + +function_IO_out_string: + move $fp, $sp + lw $a0 16($fp) + lw $a0 16($a0) + li $v0 4 + syscall + lw $v0 12($fp) + jr $ra + + +############## TABLES ################ + +function_build_class_name_table: + li $a0 28 + li $v0 9 + syscall + move $s1 $v0 + la $t1 classname_void + sw $t1 0($s1) + la $t1 classname_Object + sw $t1 4($s1) + la $t1 classname_IO + sw $t1 8($s1) + la $t1 classname_Main + sw $t1 12($s1) + la $t1 classname_Int + sw $t1 16($s1) + la $t1 classname_Bool + sw $t1 20($s1) + la $t1 classname_String + sw $t1 24($s1) + jr $ra + +function_allocate_prototypes_table: + li $a0 56 + li $v0 9 + syscall + move $s0 $v0 + jr $ra + +function_build_prototypes: + # Type void + li $a0 12 + li $v0 9 + syscall + li $a0 0 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 0($s0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + li $a0 1 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 8($s0) + + # Type IO + li $a0 12 + li $v0 9 + syscall + li $a0 2 + sw $a0 0($v0) + li $a0 12 + sw $a0 4($v0) + sw $v0 16($s0) + + # Type Main + li $a0 16 + li $v0 9 + syscall + li $a0 3 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 24($s0) + + # Type Int + li $a0 16 + li $v0 9 + syscall + li $a0 4 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 32($s0) + + # Type Bool + li $a0 16 + li $v0 9 + syscall + li $a0 5 + sw $a0 0($v0) + li $a0 16 + sw $a0 4($v0) + sw $v0 40($s0) + + # Type String + li $a0 20 + li $v0 9 + syscall + li $a0 6 + sw $a0 0($v0) + li $a0 20 + sw $a0 4($v0) + sw $v0 48($s0) + + jr $ra + +function_build_dispatch_tables: + # Type void + li $a0 0 + li $v0 9 + syscall + lw $t0 0($s0) + sw $v0 8($t0) + + # Type Object + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 8($s0) + sw $v0 8($t0) + + # Type IO + li $a0 28 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + lw $t0 16($s0) + sw $v0 8($t0) + + # Type Main + li $a0 32 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_IO_in_int + sw $t1 12($v0) + la $t1 function_IO_in_string + sw $t1 16($v0) + la $t1 function_IO_out_int + sw $t1 20($v0) + la $t1 function_IO_out_string + sw $t1 24($v0) + la $t1 function_Main_main + sw $t1 28($v0) + lw $t0 24($s0) + sw $v0 8($t0) + + # Type Int + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 32($s0) + sw $v0 8($t0) + + # Type Bool + li $a0 12 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + lw $t0 40($s0) + sw $v0 8($t0) + + # Type String + li $a0 24 + li $v0 9 + syscall + la $t1 function_Object_abort + sw $t1 0($v0) + la $t1 function_Object_copy + sw $t1 4($v0) + la $t1 function_Object_type_name + sw $t1 8($v0) + la $t1 function_String_length + sw $t1 12($v0) + la $t1 function_String_concat + sw $t1 16($v0) + la $t1 function_String_substr + sw $t1 20($v0) + lw $t0 48($s0) + sw $v0 8($t0) + + jr $ra + +function_build_class_parents_table: + li $a0 28 + li $v0 9 + syscall + move $s2 $v0 + + li $t0 2 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 4 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 5 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 6 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 1 + sw $t1 0($t0) + + li $t0 3 + mul $t0 $t0 4 + add $t0 $t0 $s2 + li $t1 2 + sw $t1 0($t0) + + jr $ra + + +########### COOL FUNCTIONS ########## + +function_Object__init: + move $fp, $sp + subu $sp, $sp, 0 + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_IO__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Main__init: + move $fp, $sp + subu $sp, $sp, 16 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_IO__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 4 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_1 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + lw $a0 -4($fp) + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Main_main: + move $fp, $sp + subu $sp, $sp, 16 + # ALLOCATE + lw $t0 32($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -12($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -12($fp) + li $a0, 3 + sw $a0 12($a1) + + # ALLOCATE + lw $t0 48($s0) + sw $t0, 0($sp) + addiu $sp, $sp, -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object_copy + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -8($fp) + + addiu $sp, $sp, 4 + + # SETATTR + lw $a1 -8($fp) + lw $a0 -12($fp) + sw $a0 12($a1) + + # SETATTR + lw $a1 -8($fp) + la $a0, data_2 + sw $a0 16($a1) + + # PUSHPARAM + lw $a0, -8($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # TYPEOF + lw $a1 12($fp) + lw $a0 0($a1) + sw $a0 0($fp) + + # VCALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + lw $a2, 0($fp) + mul $a2, $a2, 8 + addu $a2, $a2, $s0 + lw $a1, 0($a2) + lw $a2, 8($a1) + lw $a0 24($a2) + jalr $a0 + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + sw $v0 -4($fp) + lw $a2, 0($fp) + + # POPPARAM + addiu $sp $sp 4 + + # POPPARAM + addiu $sp $sp 4 + + # RETURN + lw $v0, -4($fp) + addiu $sp, $sp, 16 + jr $ra + +function_Int__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_Bool__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + +function_String__init: + move $fp, $sp + subu $sp, $sp, 0 + # PUSHPARAM + lw $a0, 12($fp) + sw $a0 0($sp) + addiu $sp $sp -4 + + # CALL + addiu $sp, $sp, -8 + sw $ra, 4($sp) + sw $fp, 8($sp) + jal function_Object__init + lw $fp, 8($sp) + lw $ra, 4($sp) + addiu $sp, $sp, 8 + + # POPPARAM + addiu $sp $sp 4 + + # SETATTR + lw $a1 12($fp) + li $a0, 0 + sw $a0 12($a1) + + # SETATTR + lw $a1 12($fp) + la $a0, data_0 + sw $a0 16($a1) + + # RETURN + lw $v0, 12($fp) + addiu $sp, $sp, 0 + jr $ra + + +##################################### +